精选列表

搜索[SpringBoot]，共4121篇文章
优秀的个人博客,低调大师

springboot+redis分布式锁-模拟抢单

本篇内容主要讲解的是redis分布式锁，这个在各大厂面试几乎都是必备的，下面结合模拟抢单的场景来使用她；本篇不涉及到的redis环境搭建，快速搭建个人测试环境，这里建议使用docker；本篇内容节点如下：1.jedis的nx生成锁2.如何删除锁3.模拟抢单动作(10w个人开抢) jedis的nx生成锁对于java中想操作redis，好的方式是使用jedis，首先pom中引入依赖： 1 <dependency>2 <groupId>redis.clients</groupId>3 <artifactId>jedis</artifactId>4 </dependency> 对于分布式锁的生成通常需要注意如下几个方面：1、创建锁的策略：redis的普通key一般都允许覆盖，A用户set某个key后，B在set相同的key时同样能成功，如果是锁场景，那就无法知道到底是哪个用户set成功的；这里jedis的setnx方式为我们解决了这个问题，简单原理是：当A用户先set成功了，那B用户set的时候就返回失败，满足了某个时间点只允许一个用户拿到锁。 2、锁过期时间：某个抢购场景时候，如果没有过期的概念，当A用户生成了锁，但是后面的流程被阻塞了一直无法释放锁，那其他用户此时获取锁就会一直失败，无法完成抢购的活动；当然正常情况一般都不会阻塞，A用户流程会正常释放锁；过期时间只是为了更有保障。 下面来上段setnx操作的代码： 1 public boolean setnx(String key, String val) { 2 Jedis jedis = null; 3 try { 4 jedis = jedisPool.getResource(); 5 if (jedis == null) { 6 return false; 7 } 8 return jedis.set(key, val, "NX", "PX", 1000 * 60). 9 equalsIgnoreCase("ok");10 } catch (Exception ex) {11 } finally {12 if (jedis != null) {13 jedis.close();14 }15 }16 return false;17 } 这里注意点在于jedis的set方法，其参数的说明如：1、NX：是否存在key，存在就不set成功2、PX：key过期时间单位设置为毫秒（EX：单位秒） setnx如果失败直接封装返回false即可，下面我们通过一个get方式的api来调用下这个setnx方法： 1 @GetMapping("/setnx/{key}/{val}")2 public boolean setnx(@PathVariable String key, @PathVariable String val) {3 return jedisCom.setnx(key, val);4 } 访问如下测试url，正常来说第一次返回了true，第二次返回了false，由于第二次请求的时候redis的key已存在，所以无法set成功 由上图能够看到只有一次set成功，并key具有一个有效时间，此时已到达了分布式锁的条件。 如何删除锁 上面是创建锁，同样的具有有效时间，但是我们不能完全依赖这个有效时间，场景如：有效时间设置1分钟，本身用户A获取锁后，没遇到什么特殊情况正常生成了抢购订单后，此时其他用户应该能正常下单了才对，但是由于有个1分钟后锁才能自动释放，那其他用户在这1分钟无法正常下单（因为锁还是A用户的），因此我们需要A用户操作完后，主动去解锁： 1 public int delnx(String key, String val) { 2 Jedis jedis = null; 3 try { 4 jedis = jedisPool.getResource(); 5 if (jedis == null) { 6 return 0; 7 } 8 9 //if redis.call('get','orderkey')=='1111' then return redis.call('del','orderkey') else return 0 end10 StringBuilder sbScript = new StringBuilder();11 sbScript.append("if redis.call('get','").append(key).append("')").append("=='").append(val).append("'").12 append(" then ").13 append(" return redis.call('del','").append(key).append("')").14 append(" else ").15 append(" return 0").16 append(" end");17 18 return Integer.valueOf(jedis.eval(sbScript.toString()).toString());19 } catch (Exception ex) {20 } finally {21 if (jedis != null) {22 jedis.close();23 }24 }25 return 0;26 } 这里也使用了jedis方式，直接执行lua脚本：根据val判断其是否存在，如果存在就del；其实个人认为通过jedis的get方式获取val后，然后再比较value是否是当前持有锁的用户，如果是那最后再删除，效果其实相当；只不过直接通过eval执行脚本，这样避免多一次操作了redis而已，缩短了原子操作的间隔。(如有不同见解请留言探讨)；同样这里创建个get方式的api来测试： 1 @GetMapping("/delnx/{key}/{val}")2 public int delnx(@PathVariable String key, @PathVariable String val) {3 return jedisCom.delnx(key, val);4 } 注意的是delnx时，需要传递创建锁时的value，因为通过et的value与delnx的value来判断是否是持有锁的操作请求，只有value一样才允许del； 模拟抢单动作(10w个人开抢)有了上面对分布式锁的粗略基础，我们模拟下10w人抢单的场景，其实就是一个并发操作请求而已，由于环境有限，只能如此测试；如下初始化10w个用户，并初始化库存，商品等信息，如下代码： 1 //总库存 2 private long nKuCuen = 0; 3 //商品key名字 4 private String shangpingKey = "computer_key"; 5 //获取锁的超时时间 秒 6 private int timeout = 30 * 1000; 7 8 @GetMapping("/qiangdan") 9 public List<String> qiangdan() {10 11 //抢到商品的用户12 List<String> shopUsers = new ArrayList<>();13 14 //构造很多用户15 List<String> users = new ArrayList<>();16 IntStream.range(0, 100000).parallel().forEach(b -> {17 users.add("神牛-" + b);18 });19 20 //初始化库存21 nKuCuen = 10;22 23 //模拟开抢24 users.parallelStream().forEach(b -> {25 String shopUser = qiang(b);26 if (!StringUtils.isEmpty(shopUser)) {27 shopUsers.add(shopUser);28 }29 });30 31 return shopUsers;32 } 有了上面10w个不同用户，我们设定商品只有10个库存，然后通过并行流的方式来模拟抢购，如下抢购的实现： 1 /** 2 * 模拟抢单动作 3 * 4 * @param b 5 * @return 6 */ 7 private String qiang(String b) { 8 //用户开抢时间 9 long startTime = System.currentTimeMillis();10 11 //未抢到的情况下，30秒内继续获取锁12 while ((startTime + timeout) >= System.currentTimeMillis()) {13 //商品是否剩余14 if (nKuCuen <= 0) {15 break;16 }17 if (jedisCom.setnx(shangpingKey, b)) {18 //用户b拿到锁19 logger.info("用户{}拿到锁...", b);20 try {21 //商品是否剩余22 if (nKuCuen <= 0) {23 break;24 }25 26 //模拟生成订单耗时操作，方便查看：神牛-50 多次获取锁记录27 try {28 TimeUnit.SECONDS.sleep(1);29 } catch (InterruptedException e) {30 e.printStackTrace();31 }32 33 //抢购成功，商品递减，记录用户34 nKuCuen -= 1;35 36 //抢单成功跳出37 logger.info("用户{}抢单成功跳出...所剩库存：{}", b, nKuCuen);38 39 return b + "抢单成功，所剩库存：" + nKuCuen;40 } finally {41 logger.info("用户{}释放锁...", b);42 //释放锁43 jedisCom.delnx(shangpingKey, b);44 }45 } else {46 //用户b没拿到锁，在超时范围内继续请求锁，不需要处理47 // if (b.equals("神牛-50") || b.equals("神牛-69")) {48 // logger.info("用户{}等待获取锁...", b);49 // }50 }51 }52 return "";53 } 这里实现的逻辑是：1、parallelStream()：并行流模拟多用户抢购2、(startTime + timeout) >= System.currentTimeMillis()：判断未抢成功的用户，timeout秒内继续获取锁3、获取锁前和后都判断库存是否还足够4、jedisCom.setnx(shangpingKey, b)：用户获取抢购锁5、获取锁后并下单成功，最后释放锁：jedisCom.delnx(shangpingKey, b) 再来看下记录的日志结果： 最终返回抢购成功的用户： git地址：https://github.com/shenniubuxing3
2019-04-01
优秀的个人博客,低调大师

补习系列(16)-springboot mongodb 数据库应用技巧

一、关于 MongoDB MongoDB 目前非常流行，在最近的DB-Engine排名中居第5位，仅次于传统的关系型数据库如 Oracle、Mysql。 然而在非关系型数据库领域，MongoDB已经持续成为佼佼者一段时间了，这与 MongoDB的一些优势存在一定关系： 无模式(Schema)，便于快速开发； 面向文档化的数据，基于BSON格式(类JSON)，灵活性强 高性能，得益于其内存计算能力； 副本集、自动分片特性，提供了高可用及水平扩展能力 MongoDB 的主要对象包括数据库（database）、集合（collection）、文档对象（document），与关系型数据库的对应关系如下： MySql MongoDB schema database table collection record document column field 与关系型数据库一样，M
2019-02-21
优秀的个人博客,低调大师

SpringBoot整合RabbitMQ之典型应用场景实战三

实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。前两篇博文我介绍分享了RabbitMQ在业务服务模块异步解耦以及通信的实战业务场景，感兴趣童鞋可以前往观看：1.https://www.roncoo.com/article/detail/134309 2.https://www.roncoo.com/article/detail/134312 这篇博文我们继续介绍分享RabbitMQ死信队列实战以及在支付系统中支付过程超时则自动失效其下单记录 这样的业务场景！ RabbitMQ 实战：死信队列认识与场景实战 死信队列认识 死信队列，又可以称之为“延迟/延时队列”，也是队列的一种，只不过与普通的队列最大的不同之处在于创建时的组成成分不同，创建死信队列的“成分”将不仅仅只是：名称、持久化、自动删除等基本属性，还包含了死信交换机、死信路由甚至还有TTL（Time-To-Live）即队列中消息可生存的时间。 死信队列其实最大的作用是可以实现消息或者数据延迟/延时处理，而且还可以动态的设定延迟的时间，即动态设定 TTL。典型的业务场景很多，在这里就不一一列举了，总之，凡是业务中需要延迟一定时间再处理的数据均可以将其压入死信队列中，等待一定的时间后再执行真正的处理逻辑！ 下面是死信队列在创建、绑定、生产消息、消费消息过程的结构流程图，在这里其实已经很明确的指出死信队列的创建跟绑定逻辑 以及 真正监听消费处理消息的队列的绑定逻辑。图中问题的答案为：当入死信队列的消息TTL一到，它自然而然的将被路由到 死信交换机绑定的队列 中被真正消费处理！！！ 死信队列场景实战 有了上面的流程图做指导，接下来，我们将用死信队列实战这样的一个业务场景：用户在商城下单成功并点击去支付后在指定时间未支付时自动失效！于是乎，我们需要创建两个消息模型，在 RabbitmqConfig 实施： 死信队列：用于设定指定的待支付的交易订单号在指定的 TTL（单位为 ms）后何去何从！ 真正队列：用于监听消费处理指定的交易订单号，即判断该交易订单号是否已完成，如果否，则失效之！ 接下来是我们的生产端的逻辑：用户商城下单的处理！ 接下来是等待固定的 TTL：在这里设定的是 10s，当消息入死信队列 10s 后，将自然而然的将消息路由到下一个中转站，即真正的消费监听处理队列进行处理：判断该笔交易订单号是否已经付款，如果否，则失效之！ 可以将该服务跑起来，然后发起 controller 的用户下单请求，会发现消息入死信队列后不会立马被消费，等待 10s 会，消息会被路由到真正的消费队列中进行处理，这一现象可以在 MQ 的后端控制台应用中看到！ 总结：到此我们的死信队列已经实战完毕，回顾我们所介绍的历程，其实核心重点在于上面的那张 “死信队列的结构流程图”，理解了这个结构流程图中的相关组件及其流程，则在实战各种需要延时处理的业务场景将得心应手，包括如何创建死信队列，如何面向生产端绑定死信队列，如何面向消费端绑定真正的队列等等！而对于死信队列的实战场景，前面也介绍过了：凡是需要等待一定时间或者需要缓一缓特定时间的业务、数据均可以通过死信队列来实现！ 可以将该服务跑起来，然后发起 controller 的用户下单请求，会发现消息入死信队列后不会立马被消费，等待 10s 会，消息会被路由到真正的消费队列中进行处理，这一现象可以在 MQ 的后端控制台应用中看到！ 回顾与总结 RabbitMQ 的认识与实际业务场景的实战到此我都已经介绍完毕，总体而言，RabbitMQ 作为目前应用相当广泛的消息中间件，在我们实际系统的业务模块中具有重要的作用，特别是刚开始介绍的几种消息模型以及死信队列模型在微服务系统、分布式系统中均可充当重要的角色，其中我们实战的业务场景包括业务服务模块解耦异步通信（异步发送日志、异步发送邮件）；另外，我们还介绍了消息确认机制，这是一种 MQ 确保消息能被消费者消费的机制，对于一些业务模块也是有广泛的应用；除此之外，我们还模拟实战了秒杀系统、抢单系统这样的业务场景下 RabbitMQ 的作用：限流、排队缓压、减少数据库读写锁的发生等等！ 彩蛋：本博文介绍了RabbitMQ死信队列及其业务场景的实战，此业务场景其实适用于任何需要“延迟一定时间处理”的业务，包括本博文介绍的 “支付系统-用户下单点击去支付后超时仍未支付成功时则需要暂时失效其下单记录”！另外，博主已将RabbitMQ相关技术以及场景实战的相关要点录制成了视频教程，感兴趣小伙伴可以前往学习观看：https://www.roncoo.com/course/view/95ffac8bd3aa4f2d8a0d83c32f46c69d
2018-11-29
优秀的个人博客,低调大师

第十二篇:SpringBoot 2.x数据校验

介绍 在项目的过程中，对于参数的校验是必须的，如果参数比较少的话我们可以直接通过代码进行校验，但是数据较大时再用这个方法就比较笨重了，接下来就该我们的主角Validation闪亮登场了 pom.xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> 实际上在这里数据校验都是调用的javax.validation，spring-boot-starter-web中也包含了hibernate-validator，有兴趣的可以去翻翻文档 User.java package com.priv.gabriel.entity; import lombok.Data; import org.hibernate.validator.constraints.Length; import javax.validation.constraints.Min; import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotNull; /** * Created with Intellij IDEA. * * @Author: Gabriel * @Date: 2018-10-23 * @Description: */ @Data public class User { @NotBlank(message = "name不允许为空") @Length(min = 2,max = 10,message = "你的长度不对劲呀") private String name; @NotNull(message = "进入未成年人入内！") @Min(18) private int age; @NotBlank(message = "拒绝黑户") private String address; } 接下来只需要在Controller层中使用@valid进行校验就可以了 package com.priv.gabriel.controller; import com.priv.gabriel.entity.User; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import javax.validation.Valid; /** * Created with Intellij IDEA. * * @Author: Gabriel * @Date: 2018-10-23 * @Description: */ @RestController @RequestMapping("/user") public class UserController { @RequestMapping("/check") public String check(@Valid User user){ return "检测完毕！没有问题"; } } 用Rest Client工具简单检测一下 image.png 结果当然是... { "timestamp": "2018-10-23T09:01:45.159+0000", "status": 400, "error": "Bad Request", "errors": [{ "codes": ["Length.user.name", "Length.name", "Length.java.lang.String", "Length"], "arguments": [{ "codes": ["user.name", "name"], "arguments": null, "defaultMessage": "name", "code": "name" }, 10, 2], "defaultMessage": "你的长度不对劲呀", "objectName": "user", "field": "name", "rejectedValue": "", "bindingFailure": false, "code": "Length" }, { "codes": ["Min.user.age", "Min.age", "Min.int", "Min"], "arguments": [{ "codes": ["user.age", "age"], "arguments": null, "defaultMessage": "age", "code": "age" }, 18], "defaultMessage": "最小不能小于18", "objectName": "user", "field": "age", "rejectedValue": 17, "bindingFailure": false, "code": "Min" }, { "codes": ["NotBlank.user.address", "NotBlank.address", "NotBlank.java.lang.String", "NotBlank"], "arguments": [{ "codes": ["user.address", "address"], "arguments": null, "defaultMessage": "address", "code": "address" }], "defaultMessage": "拒绝黑户", "objectName": "user", "field": "address", "rejectedValue": "", "bindingFailure": false, "code": "NotBlank" }, { "codes": ["NotBlank.user.name", "NotBlank.name", "NotBlank.java.lang.String", "NotBlank"], "arguments": [{ "codes": ["user.name", "name"], "arguments": null, "defaultMessage": "name", "code": "name" }], "defaultMessage": "name不允许为空", "objectName": "user", "field": "name", "rejectedValue": "", "bindingFailure": false, "code": "NotBlank" }], "message": "Validation failed for object='user'. Error count: 4", "path": "/user/check" } 好了，到这里可以看到我们的设置已经生效了，关于数据校验你get到了吗？项目下载地址
2018-10-23
优秀的个人博客,低调大师

第五篇:SpringBoot 2.x整合BeetlSQL

image.png 上图是 BeetlSQL官网中对BeetlSQL的介绍，简单来说我们可以得到几个点 开发效率高 维护性好 性能数倍于JPA MyBatis 关于BeetlSQL的更多介绍大家可以去到官网去看看，接下来我们来看看如何把这个DAO工具整合到项目中 pom.xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- 引入beetlsql --> <dependency> <groupId>com.ibeetl</groupId> <artifactId>beetlsql</artifactId> <version>2.10.34</version> </dependency> <!-- 引入beetl --> <dependency> <groupId>com.ibeetl</groupId> <artifactId>beetl</artifactId> <version>2.9.3</version> </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> </dependency> </dependencies> sql文件，我这里用的是mysql CREATE TABLE `test`.`Untitled` ( `id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, `nickname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, `age` int(11) NULL DEFAULT 18, `cdate` timestamp(0) NULL DEFAULT CURRENT_TIMESTAMP(0), `udate` timestamp(0) NULL DEFAULT CURRENT_TIMESTAMP(0), PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic; User.java package com.priv.gabriel.entity; /** * Created with Intellij IDEA. * * @Author: Gabriel * @Date: 2018-10-14 * @Description: */ public class User { private long id; private String username; private String nickname; private int age; 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 getNickname() { return nickname; } public void setNickname(String nickname) { this.nickname = nickname; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "User{" + "id=" + id + ", username='" + username + '\'' + ", nickname='" + nickname + '\'' + ", age=" + age + '}'; } } 在这里有两个分支，一种是通过sqlManager来操作，另一种是整合mapper，在这里我们现看看第一种方式 SQLManager方式 UserControllerForSQLManager.java package com.priv.gabriel.controller; import com.priv.gabriel.entity.User; import com.priv.gabriel.repository.UserRepository; import org.beetl.sql.core.SQLManager; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import java.util.List; /** * Created with Intellij IDEA. * * @Author: Gabriel * @Date: 2018-10-14 * @Description: */ @RestController @RequestMapping("/sqlManager/users") public class UserControllerForSQLManager { //自动注入即可 @Autowired private SQLManager sqlManager; /* * @Author Gabriel * @Description 根据主键查找记录 * @Date 2018/10/16 * @Param [id] 主键 * @Return void */ @RequestMapping(value = "/{id}",method = RequestMethod.GET) public User selectUserById(@PathVariable("id")int id){ //如果没有查到数据则抛出异常 //return sqlManager.unique(User.class,id); //如果没有查到数据则返回null return sqlManager.single(User.class,id); } /* * @Author Gabriel * @Description 查询所有 * @Date 2018/10/16 * @Param [] * @Return java.util.List<com.priv.gabriel.entity.User>*/ @RequestMapping(value = {"","/"},method = RequestMethod.GET) public List<User> getUsers(){ //获取所有数据 //return sqlManager.all(User.class); //查询该表的总数 //return sqlManager.allCount(User.class); //获取所有数据 分页方式 return sqlManager.all(User.class,1,2); } /* * @Author Gabriel * @Description 单表条件查询 * @Date 2018/10/16 * @Param [] * @Return void*/ public void singletonTableQuery(){ //通过sqlManager.query()可以在后面追加各种条件 sqlManager.query(User.class).andLike("username","admin").orderBy("age").select(); } /* * @Author Gabriel * @Description 新增数据 * @Date 2018/10/16 * @Param [user] * @Return void*/ @RequestMapping(value = {"","/"},method = RequestMethod.POST) public void addUser(User user){ //添加数据到对应表中 //sqlManager.insert(User.class,user); //添加数据到对应表中，并返回自增id sqlManager.insertTemplate(user,true); System.out.println(user.getId()); System.out.println("新增成功"); } /* * @Author Gabriel * @Description 根据主键修改 * @Date 2018/10/16 * @Param [user] * @Return java.lang.String*/ @RequestMapping(value = {"","/"},method = RequestMethod.PUT) public String updateById(User user){ //根据id修改，所有值都参与更新 //sqlManager.updateById(user); //根据id修改,属性为null的不会更新 if(sqlManager.updateTemplateById(user)>0){ return "修改成功"; }else{ return "修改失败"; } } /* * @Author Gabriel * @Description 删除记录 * @Date 2018/10/16 * @Param [id] * @Return java.lang.String*/ @RequestMapping(value = "/id",method = RequestMethod.DELETE) public String deleteById(@PathVariable("id") int id){ if(sqlManager.deleteById(User.class,id) >0 ){ return "删除成功"; }else{ return "删除失败"; } } } Mapper方式 如果要使用mapper方式，则需要新建一个mapper接口，并继承BaseMapper<T> UserRepository.java package com.priv.gabriel.repository; import com.priv.gabriel.entity.User; import org.beetl.sql.core.mapper.BaseMapper; /** * Created with Intellij IDEA. * * @Author: Gabriel * @Date: 2018-10-14 * @Description: */ public interface UserRepository extends BaseMapper<User>{ } UserControllerForMapper.java package com.priv.gabriel.controller; import com.priv.gabriel.entity.User; import com.priv.gabriel.repository.UserRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import java.util.List; /** * Created with Intellij IDEA. * * @Author: Gabriel * @Date: 2018-10-14 * @Description: */ @RestController @RequestMapping("/mapper/users") public class UserControllerForMapper { @Autowired private UserRepository repository; @RequestMapping(value = {"","/"},method = RequestMethod.POST) public void addUser(User user){ repository.insert(user); } @RequestMapping(value = {"","/"},method = RequestMethod.DELETE) public String deleteUserById(User user){ if(repository.deleteById(user) >0 ){ return "删除成功"; }else{ return "删除失败"; } } @RequestMapping(value = {"","/"},method = RequestMethod.PUT) public String updateUserById(User user){ //repository.updateById(user) if(repository.deleteById(user) > 0){ return "修改成功"; }else{ return "修改失败"; } } @RequestMapping(value = "/{id}",method = RequestMethod.GET) public User selectUserById(@PathVariable("id")int id){ //repository.unique(id); return repository.single(id); } @RequestMapping(value = {"","/"},method = RequestMethod.GET) public List<User> getUsers(){ //repository.all(1,2); //repository.allCount(); return repository.all(); } } 两种方式都介绍完毕了，但是BeetlSQL的重点部分还不在这，BeetlSQL的重点是可以创建一个SQL模板，到这大家可能会想，不就是个xml嘛，mybatis就有呀，不一样的地方就在这了，BeetlSQL的SQL模板是这样的 selectByTest === select * from user where 1=1 怎么样，是不是眼前一亮，很明显 selectByTest 是这条SQL语句的id , ===的作用是代表id和内容的分割，而最后的部分当然就是SQL语句啦 然后简单介绍一下调用SQL模板的方式 SQLManager方式 @RequestMapping(value = "/test",method = RequestMethod.GET) public List<User> getUsersByTest(){ return sqlManager.select("user.selectByTest",User.class); } 在SQLManager的方式中，通过sqlManager.select("模板id"，类型)的方式直接调用 Mapper的方式 @SqlResource("user") public interface UserRepository extends BaseMapper<User>{ List<User> selectByTest(); } 在Mapper的方式，需要先建立一个xxx.md的SQL模板文件,通过@SqlResource(模板文件名)这个注解找到模板文件，再在mapper中写入与模板文件中同名的方法，即可在外部调用 注意，BeetlSQL的模板文件位置默认在resource/sql/xxx.md中，好啦，关于BeetlSQL的介绍就到这里。 BeetlSQL的详细介绍Beetl官方文档BeetlSQL官方文档项目点此下载
2018-10-16
优秀的个人博客,低调大师

Spring Cloud 2.x系列之springboot集成quartz

java设计模式之观察者模式 一大波视频分享 Mysql代理中间件Atlas安装和配置 在做项目时有时候会有定时器任务的功能，比如某某时间应该做什么，多少秒应该怎么样之类的。定时任务常用的业务场景是进行数据统计。spring支持多种定时任务的实现，今天介绍一下spring定时器和quartz定时器的使用。 一、spring定时器 spring自带支持定时器的任务实现。其可通过简单配置来实现定时任务。主要用到如下两注解： @EnableScheduling：标注启动定时任务 @Scheduled：定义某个定时任务 常用说明： @Scheduled(fixedRate=2000)：上一次开始执行时间点后2秒再次执行 @Scheduled(fixedDelay=2000)：上一次执行完毕时间点后2秒再次执行 @Scheduled(initialDelay=1000,fixedDelay=2000)：第一次延迟1秒执行，然后在上一次执行完毕时间点后2秒再次执行 @Scheduled(cron="** * * * ?")：按cron规则执行 二、quartz定时任务 quzrtz主要理解如下几个概念： Job：是一个接口，只有一个方法void execute(JobExecutionContext context)，开发者实现该接口定义运行任务，JobExecutionContext类提供了调度上下文的各种信息。Job运行时的信息保存在JobDataMap实例中。 JobDetail：Quartz在每次执行Job时，都重新创建一个Job实例，所以它不直接接受一个Job的实例，相反它接收一个Job实现类，以便运行时通过newInstance()的反射机制实例化Job。因此需要通过一个类来描述Job的实现类及其它相关的静态信息，如Job名字、描述、关联监听器等信息，JobDetail承担了这一角色。 Trigger：是一个类，描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当仅需触发一次或者以固定时间间隔周期执行，SimpleTrigger是最适合的选择；而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案：如每凌晨1:00执行，周一、周三、周五下午5:00执行等； Calendar：org.quartz.Calendar和java.util.Calendar不同，它是一些日历特定时间点的集合（可以简单地将org.quartz.Calendar看作java.util.Calendar的集合——java.util.Calendar代表一个日历时间点，无特殊说明后面的Calendar即指org.quartz.Calendar）。一个Trigger可以和多个Calendar关联，以便排除或包含某些时间点。假设，我们安排每周星期一早上10:00执行任务，但是如果碰到法定的节日，任务则不执行，这时就需要在Trigger触发机制的基础上使用Calendar进行定点排除。 Scheduler：代表一个Quartz的独立运行容器，Trigger和JobDetail可以注册到Scheduler中，两者在Scheduler中拥有各自的组及名称，组及名称是Scheduler查找定位容器中某一对象的依据，Trigger的组及名称必须唯一，JobDetail的组和名称也必须唯一（但可以和Trigger的组和名称相同，因为它们是不同类型的）。Scheduler定义了多个接口方法，允许外部通过组及名称访问和控制容器中Trigger和JobDetail。 1、新建项目，对应的pom.xml文件如下 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>spring-cloud</groupId> <artifactId>sc-scheduled</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>sc-scheduled</name> <url>http://maven.apache.org</url> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.4.RELEASE</version> </parent> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>Finchley.RELEASE</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- 集成quartz需要引入 --> <!--quartz相关依赖--> <!-- <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> </dependency> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz-jobs</artifactId> </dependency>--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> </dependencies> </project> 2、新建sprinboot启动类ScheduledApplication.java package sc.schedule; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.scheduling.annotation.EnableScheduling; @SpringBootApplication @EnableScheduling // 开启spring自带定时任务 publicclass ScheduledApplication { public static void main(String[] args) { SpringApplication.run(ScheduledApplication.class, args); } } 3、Spring定时任务类 packagesc.schedule.spring; import java.text.SimpleDateFormat; import java.util.Date; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; @Component public class SpringScheduled { // 每1分钟执行一次 @Scheduled(cron = "0 */1 * ** * ") public void reportCurrentByCron() { System.out.println("Spring Scheduling Tasks: " + dateFormat().format(new Date())); } private SimpleDateFormat dateFormat() { returnnewSimpleDateFormat("HH:mm:ss"); } } 4、Quartz定时任务类 单任务模式： package sc.schedule.quartz; import org.quartz.JobDetail; import org.quartz.Trigger; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.quartz.CronTriggerFactoryBean; import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean; importorg.springframework.scheduling.quartz.SchedulerFactoryBean; @Configuration publicclass QuartzScheduledOne { @Bean public ScheduledJobOne getScheduledJobOne(){ return new ScheduledJobOne(); } /** * 调度工厂 * *@param jobTrigger * 触发器 *@return */ @Bean(name = "scheduler") public SchedulerFactoryBean schedulerFactory(Trigger jobTrigger) { SchedulerFactoryBeanfactoryBean = new SchedulerFactoryBean(); // 用于quartz集群,QuartzScheduler 启动时更新己存在的Job factoryBean.setOverwriteExistingJobs(true); // 延时启动，应用启动1秒后 factoryBean.setStartupDelay(1); // 注册触发器 factoryBean.setTriggers(jobTrigger); return factoryBean; } /** * * 定时触发器 * *@param reptilianJob * 任务 * *@return * */ @Bean(name = "jobTrigger") public CronTriggerFactory BeancronJobTrigger(JobDetail jobDetail) { CronTriggerFactoryBean tigger = newCronTriggerFactoryBean(); tigger.setJobDetail(jobDetail); // cron表达式，每1分钟执行一次 tigger.setCronExpression("0/20 ** * * ?"); tigger.setName("jobTrigger"); return tigger; } /** * 配置任务 * *@param quartzTask * QuartzTask为需要执行的任务 *@return */ @Bean(name = "jobDetail") public MethodInvokingJobDetailFactory BeandetailFactoryBean(ScheduledJobOne quartzTask) { MethodInvokingJobDetailFactoryBeanjobDetail = new MethodInvokingJobDetailFactoryBean(); // 是否并发执行 jobDetail.setConcurrent(false); // 设置任务的名字 jobDetail.setName("jobDetail"); // 设置任务的分组，在多任务的时候使用 jobDetail.setGroup("jobDetailGroup"); // 需要执行的对象 jobDetail.setTargetObject(quartzTask); /* * TODO非常重要 执行QuartzTask类中的需要执行方法 */ jobDetail.setTargetMethod("execute"); return jobDetail; } } 任务模式参考源码 5、对应的类结构说明 6、启动ScheduledApplication类，并验证定时任务是否启动 (1)注释QuartzScheduled类的Configuration注解 启动ScheduledApplication类查看日志： (2)放开QuartzScheduled类的Configuration注解，然后注释QuartzScheduled类的Configuration注解 启动ScheduledApplication类查看日志： 源码： https://gitee.com/hjj520/spring-cloud-2.x/tree/master/sc-scheduled 本文作者：java乐园 本文来自云栖社区合作伙伴“JAVA乐园”，了解相关信息可以关注“JAVA乐园”
2018-10-15
优秀的个人博客,低调大师

精通SpringBoot——第九篇：整合Swagger在线文档

开发中最烦的一件事是什么？当你全心全意思考的时候，前端笑眯眯的过来了：“大哥，你没告诉我该传什么参数！”......然后一堆吧啦吧啦扯淡，好了，前端大佬心满意足的走了，你以为事情也就这么结束了。滴滴滴，微信消息来了：“接口怎么不通啊，你是不是代码写的有问题啊？”一顿操作后，登上控制台，日志一看。啊~（我们一起学土拨鼠叫）内心是崩溃的... 参数少了，参数类型不对，格式不对，各种。这时候很想丢个文档给前端：你自己看吧！然而，写文档真的太麻烦了，懒...只好去逛逛论坛，百度谷歌下有没有什么生成在线文档的工具了，结果如你所愿，还真有。今儿个，咱们就来走一波spring boot 整合 swagger 生成在线文档。（呼~~爽，感觉用了这个，就可以不用被前端大佬“骚扰”了）。介绍两种集成swagger的方式，越用越爽。写文档的时候可以用来和基友尬聊了（编程五分钟，扯淡两小时，一天就这么没了...） 第一招 Without Starter 新建项目,pom 文件加上两个swagger必要的依赖。 <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>${swagger.version}</version> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger-ui</artifactId> <version>${swagger.version}</version> </dependency> Swagger的配置文件 @Configuration @EnableSwagger2 public class SwaggerConfig { /** * swagger通过注解表明该接口会生成文档，包括接口名、请求方法、参数、返回信息的等等。 * * @return * @Api：修饰整个类，描述Controller的作用 * @ApiOperation：描述一个类的一个方法，或者说一个接口 * @ApiParam：单个参数描述 * @ApiModel：用对象来接收参数 * @ApiProperty：用对象接收参数时，描述对象的一个字段 * @ApiResponse：HTTP响应其中1个描述 * @ApiResponses：HTTP响应整体描述 * @ApiIgnore：使用该注解忽略这个API * @ApiError：发生错误返回的信息 * @ApiImplicitParam：一个请求参数 * @ApiImplicitParams：多个请求参数 */ @Bean public Docket createRestApi() { /**添加head参数start*/ ParameterBuilder tokenPar = new ParameterBuilder(); List<Parameter> pars = new ArrayList<Parameter>(); tokenPar.name("authorization").description("令牌").modelRef(new ModelRef("string")).parameterType("header").required(false).build(); pars.add(tokenPar.build()); //添加head参数end return new Docket(DocumentationType.SWAGGER_2) .groupName("com.developlee.HangZhou.ZheJiang") .select() .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class)) //有该注解的生成doc .apis(RequestHandlerSelectors.basePackage("com.developlee.swagger")) // 自行修改为自己的包路径 .paths(PathSelectors.any()) .build() .globalOperationParameters(pars) //set Header .apiInfo(apiInfo()); } private ApiInfo apiInfo() { return new ApiInfoBuilder() .title("DevelopLee的Swagger在线文档") .description("嗯哼嗯哼额~~~swagger文档很强！") .termsOfServiceUrl("http://github.com/developlee") .version("1.0") .build(); } } 写个Controller类测试 @RestController public class UserController { @GetMapping("/userInfo") @ApiOperation(notes = "获取用户信息", value = "get user info") public String getUserInfo(){ return "getUserInfo"; } @PostMapping("/addUser") @ApiOperation(notes = "添加用户信息", value = "add user info") @ApiImplicitParam(value = "添加用户", name = "add user", dataType = "java.lang.String", required = true) public String addUser(String str){ return "addUser"; } } 启动项目...访问 localhost:8080/swagger-ui.html（我滴个龟龟，这就好了？）感动到哭，前端大佬们， see you la la~~（事实上我去找他们聊天了，感受下这个文档带给后端开发人员的福利，尤其是惰性开发人员，比如在座的所有人) 第二招 With swagger-spring-boot-starter 这里介绍一个相当牛逼的工具，来自spring4all.com社区开源的swagger-spring-boot-starter。接下来我们就用这个依赖包开发swagger 文档。pom.xml依赖 <dependency> <groupId>com.spring4all</groupId> <artifactId>swagger-spring-boot-starter</artifactId> <version>1.7.1.RELEASE</version> </dependency> @EnableSwagger2Doc开启文档 @SpringBootApplication @EnableSwagger2Doc public class SwaggerStarterApplication { public static void main(String[] args) { SpringApplication.run(SwaggerStarterApplication.class, args); } } 配置示例： swagger.enabled=true swagger.title=spring-boot-starter-swagger swagger.description=Starter for swagger 2.x swagger.version=1.7.1.RELEASE swagger.license=Apache License, Version 2.0 swagger.licenseUrl=https://www.apache.org/licenses/LICENSE-2.0.html swagger.termsOfServiceUrl=https://github.com/dyc87112/spring-boot-starter-swagger swagger.contact.name=developlee swagger.contact.url=http://github.com/developlee swagger.contact.email=developlee@163.com swagger.base-package=com.developlee swagger.base-path=/** swagger.exclude-path=/error, /ops/** swagger.globalOperationParameters[0].name=name one swagger.globalOperationParameters[0].description=some description one swagger.globalOperationParameters[0].modelRef=string swagger.globalOperationParameters[0].parameterType=header swagger.globalOperationParameters[0].required=true swagger.globalOperationParameters[1].name=name two swagger.globalOperationParameters[1].description=some description two swagger.globalOperationParameters[1].modelRef=string swagger.globalOperationParameters[1].parameterType=body swagger.globalOperationParameters[1].required=false // 取消使用默认预定义的响应消息,并使用自定义响应消息 swagger.apply-default-response-messages=false swagger.global-response-message.get[0].code=401 swagger.global-response-message.get[0].message=401get swagger.global-response-message.get[1].code=500 swagger.global-response-message.get[1].message=500get swagger.global-response-message.get[1].modelRef=ERROR swagger.global-response-message.post[0].code=500 swagger.global-response-message.post[0].message=500post swagger.global-response-message.post[0].modelRef=ERROR 配置说明--默认配置 - swagger.enabled=是否启用swagger，默认：true - swagger.title=标题 - swagger.description=描述 - swagger.version=版本 - swagger.license=许可证 - swagger.licenseUrl=许可证URL - swagger.termsOfServiceUrl=服务条款URL - swagger.contact.name=维护人 - swagger.contact.url=维护人URL - swagger.contact.email=维护人email - swagger.base-package=swagger扫描的基础包，默认：全扫描 - swagger.base-path=需要处理的基础URL规则，默认：/** - swagger.exclude-path=需要排除的URL规则，默认：空 - swagger.host=文档的host信息，默认：空 - swagger.globalOperationParameters[0].name=参数名 - swagger.globalOperationParameters[0].description=描述信息 - swagger.globalOperationParameters[0].modelRef=指定参数类型 - swagger.globalOperationParameters[0].parameterType=指定参数存放位置,可选header,query,path,body.form - swagger.globalOperationParameters[0].required=指定参数是否必传，true,false Path设置 management.context-path=/ops swagger.base-path=/** swagger.exclude-path=/ops/**, /error 上面的设置将解析所有除了/ops/开始以及spring boot自带/error请求路径。 其中，exclude-path可以配合management.context-path=/ops设置的spring boot actuator的context-path来排除所有监控端点。 分组配置 - swagger.docket.<name>.title=标题 - swagger.docket.<name>.description=描述 - swagger.docket.<name>.version=版本 - swagger.docket.<name>.license=许可证 - swagger.docket.<name>.licenseUrl=许可证URL - swagger.docket.<name>.termsOfServiceUrl=服务条款URL - swagger.docket.<name>.contact.name=维护人 - swagger.docket.<name>.contact.url=维护人URL - swagger.docket.<name>.contact.email=维护人email - swagger.docket.<name>.base-package=swagger扫描的基础包，默认：全扫描 - swagger.docket.<name>.base-path=需要处理的基础URL规则，默认：/** - swagger.docket.<name>.exclude-path=需要排除的URL规则，默认：空 - swagger.docket.<name>.name=参数名 - swagger.docket.<name>.modelRef=指定参数类型 - swagger.docket.<name>.parameterType=指定参数存放位置,可选header,query,path,body.form - swagger.docket.<name>.required=true=指定参数是否必传，true,false - swagger.docket.<name>.globalOperationParameters[0].name=参数名 - swagger.docket.<name>.globalOperationParameters[0].description=描述信息 - swagger.docket.<name>.globalOperationParameters[0].modelRef=指定参数存放位置,可选header,query,path,body.form - swagger.docket.<name>.globalOperationParameters[0].parameterType=指定参数是否必传，true,false 更多移步至 github.com。 最后，以上示例代码可在我的github.com中找到。我的个人公众号：developlee的潇洒人生。关注了也不一定更新，更新就不得了了。
2018-08-06
优秀的个人博客,低调大师

精通SpringBoot——第四篇：Spring事件 Application Event

Spring的事件为Bean与Bean之间的通信提供了支持，当我们系统中某个Spring管理的Bean处理完某件事后，希望让其他Bean收到通知并作出相应的处理，这时可以让其他Bean监听当前这个Bean所发送的事件。 要实现事件的监听，我们要做两件事：1：自定义事件，继承ApplicationEvent接口2：定义事件监听器，实现ApplicationListener3：事件发布类 /** * @TODO // 自定义事件，继承ApplicationEvent接口 * @Author Lensen * @Date 2018/7/22 * @Description */ public class SendMsgEvent extends ApplicationEvent { private static final long serialVersionID = 1L; // 收件人 public String receiver; // 收件内容 public String content; public SendMsgEvent(Object source) { super(source); } public SendMsgEvent(Object source, String receiver, String content) { super(source); this.receiver = receiver; this.content = content; } public void output(){ System.out.println("I had been sand a msg to " + this.receiver); } } /** * @TODO //定义事件监听器，实现ApplicationListener * @Author Lensen * @Date 2018/7/22 * @Description */@Component public class MsgListener implements ApplicationListener<SendMsgEvent> { @Override public void onApplicationEvent(SendMsgEvent sendMsgEvent) { sendMsgEvent.output(); System.out.println(sendMsgEvent.receiver + "received msg : " + sendMsgEvent.content ); } } 事件发布类 @Component public class Publisher { @Autowired ApplicationContext applicationContext; public void publish(Object source, String receiver, String content){ applicationContext.publishEvent(new SendMsgEvent(source, receiver, content)); } } 测试消息：WebConfig.class主要是为了扫描Publisher 和Listener类。里面有两个注解@ComponenScan和@Configuration。 public static void main(String[] args) { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(WebConfig.class); Publisher publisher = applicationContext.getBean(Publisher.class); publisher.publish("Hello,World!","Mr.Lensen", "I Love U"); } 结果： I had been sand a msg to Mr.Lensen Mr.Lensen received msg : I Love U
2018-07-22

资源下载

更多资源
Mario，低调大师唯一一个Java游戏作品

Mario，低调大师唯一一个Java游戏作品

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Oracle Database，又名Oracle RDBMS

Oracle Database，又名Oracle RDBMS

Oracle Database，又名Oracle RDBMS，或简称Oracle。是甲骨文公司的一款关系数据库管理系统。它是在数据库领域一直处于领先地位的产品。可以说Oracle数据库系统是目前世界上流行的关系数据库管理系统，系统可移植性好、使用方便、功能强，适用于各类大、中、小、微机环境。它是一种高效率、可靠性好的、适应高吞吐量的数据库方案。

Java Development Kit(Java开发工具)

Java Development Kit(Java开发工具)

JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。

Sublime Text 一个代码编辑器

Sublime Text 一个代码编辑器

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

热门标签
ChatGPT SpringBoot Nacos SpringCloud K8s HarmonyOS NEXT Redis DeepSeek Jdk25 服务网格 Docker

欢迎您！

登录后，您将获得更多功能！

热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273