SpringBoot整合
MyBatis在SpringBoot中使用
依赖加入
<!--mybatis-plus-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.3.1</version>
</dependency>
<!--逆向工程-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
</dependency>
配置文件(application.yml)
@MapperScan("com.atguigu.yygh.mapper")
spring:
profiles:
active: dev # 环境设置
application:
name: service-edu # 不用_下划线兼容会好些
datasource:
username: root
password: 123456
url: jdbc:mysql://localhost:3306/db_01_guli_edu?serverTimezone=GMT%2B8&characterEncoding=utf8
driver-class-name: com.mysql.cj.jdbc.Driver
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # MyBaits日志
mapper-locations: classpath:com/atguigu/guli/service/edu/mapper/xml/*.xml
public interface UserMapper extends BaseMapper<User> {
}
public interface HospitalSetService extends IService<HospitalSet> {
}
@service
public class HospitalSetServiceImpl extends ServiceImpl<HospitalSetMapper,HospitalSet> implements HospitalSetService {
}
自动填充时间
属性加上
@TableField(fill = FieldFill.INSERT)
private Date createTime;
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
配置:
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
// mp执行添加操作,这个方法执行
@Override
public void insertFill(MetaObject metaObject) {
setFieldValByName("createTime",new Date(),metaObject);
setFieldValByName("updateTime",new Date(),metaObject);
}
// 执行修改操作,这个方法执行
@Override
public void updateFill(MetaObject metaObject) {
this.setFieldValByName("updateTime",new Date(),metaObject);
}
}
乐观锁配置
数据库中要有个version字段
类的字段配置
@Version
private Integer version;
乐观锁配置
@Configuration
public class MpConf {
/**
* 乐观锁插件
* @return
*/
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor(){
return new OptimisticLockerInterceptor();
}
}
分页需要做的
@EnableTransactionManagement
@Configuration
@MapperScan("com.atguigu.guli.service.*.mapper")
public class MybatisPlusConfig {
/**
* 分页插件
*/
@Bean
public PaginationInterceptor paginationInterceptor() {
return new PaginationInterceptor();
}
}
示例
@Test
public void test2(){
Page<User> userPage1 = new Page<>(1, 4);
Page<User> userPage = userMapper.selectPage(userPage1, null);
List<User> records = userPage.getRecords();
records.forEach(System.out::println);
}
逻辑删除
添加 deleted字段
ALTERTABLE `user` ADD COLUMN `deleted` boolean DEFAULT false
添加deleted 字段,并加上 @TableLogic 注解
@TableLogic
private Integer deleted;
配置(可选)
application.properties 加入以下配置,此为默认值,如果你的默认值和mp默认的一样,该配置可无
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0
SpringBoot和MongoDB整合
启动mongoDB 失败是服务没启动 命令mongod --dbpath /data/db --bind_ip 0.0.0.0
spring-data-mongodb提供了MongoTemplate与MongoRepository两种方式访问
mongodb,MongoRepository操作简单,MongoTemplate操作灵活,
我们在项目中可以灵活适用这两种方式操作mongodb,MongoRepository的缺点是不够灵活,MongoTemplate正好可以弥补不足。
第一步:依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--日期的工具-->
<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>2.10.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
第二步:配置文件
spring.data.mongodb.uri=mongodb://192.168.179.200:27017/test
第三步:创建对应的类
@Data
@Document("User")
public class User {
@Id
private String id;
private String name;
private Integer age;
private String email;
private String createDate;
}
MongoTemplate
@SpringBootTest
class DemomogoApplicationTests {
@Autowired
private MongoTemplate mongoTemplate;
//添加
@Test
public void createUser() {
User user = new User();
user.setAge(20);
user.setName("test");
user.setEmail("4932200@qq.com");
User user1 = mongoTemplate.insert(user);
System.out.println(user1);
}
//查询所有
@Test
public void findUser() {
List<User> userList = mongoTemplate.findAll(User.class);
System.out.println(userList);
}
//根据id查询
@Test
public void getById() {
User user =
mongoTemplate.findById("5ffbfa2ac290f356edf9b5aa", User.class);
System.out.println(user);
}
//条件查询
@Test
public void findUserList() {
Query query = new Query(Criteria
.where("name").is("test")
.and("age").is(20));
List<User> userList = mongoTemplate.find(query, User.class);
System.out.println(userList);
}
//模糊查询
@Test
public void findUsersLikeName() {
String name = "est";
String regex = String.format("%s%s%s", "^.*", name, ".*$");
Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
Query query = new Query(Criteria.where("name").regex(pattern));
List<User> userList = mongoTemplate.find(query, User.class);
System.out.println(userList);
}
//分页查询
@Test
public void findUsersPage() {
String name = "est";
int pageNo = 1;
int pageSize = 10;
Query query = new Query();
String regex = String.format("%s%s%s", "^.*", name, ".*$");
Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
query.addCriteria(Criteria.where("name").regex(pattern));
int totalCount = (int) mongoTemplate.count(query, User.class);
List<User> userList = mongoTemplate.find(query.skip((pageNo - 1) * pageSize).limit(pageSize), User.class);
Map<String, Object> pageMap = new HashMap<>();
pageMap.put("list", userList);
pageMap.put("totalCount",totalCount);
System.out.println(pageMap);
}
//修改
@Test
public void updateUser() {
User user = mongoTemplate.findById("5ffbfa2ac290f356edf9b5aa", User.class);
user.setName("test_1");
user.setAge(25);
user.setEmail("493220990@qq.com");
Query query = new Query(Criteria.where("_id").is(user.getId()));
Update update = new Update();
update.set("name", user.getName());
update.set("age", user.getAge());
update.set("email", user.getEmail());
UpdateResult result = mongoTemplate.upsert(query, update, User.class);
long count = result.getModifiedCount();
System.out.println(count);
}
//删除操作
@Test
public void delete() {
Query query =
new Query(Criteria.where("_id").is("5ffbfa2ac290f356edf9b5aa"));
DeleteResult result = mongoTemplate.remove(query, User.class);
long count = result.getDeletedCount();
System.out.println(count);
}
}
MongoRepository (可以使用命名方式来查询)
public interface UserRepository extends MongoRepository<User, String> {
}
@SpringBootTest
class DemomogoApplicationTests1 {
@Autowired
private UserRepository userRepository;
//添加
@Test
public void createUser() {
User user = new User();
user.setAge(20);
user.setName("张三");
user.setEmail("3332200@qq.com");
User user1 = userRepository.save(user);
}
//查询所有
@Test
public void findUser() {
List<User> userList = userRepository.findAll();
System.out.println(userList);
}
//id查询
@Test
public void getById() {
User user = userRepository.findById("5ffbfe8197f24a07007bd6ce").get();
System.out.println(user);
}
//条件查询
@Test
public void findUserList() {
User user = new User();
user.setName("张三");
user.setAge(20);
Example<User> userExample = Example.of(user);
List<User> userList = userRepository.findAll(userExample);
System.out.println(userList);
}
//模糊查询
@Override
public List<Hospital> findByHosname(String hosname) {
return hospitalRepository.findHospitalByHosnameLike(hosname);
}
//模糊查询
@Test
public void findUsersLikeName() {
//创建匹配器,即如何使用查询条件
ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
.withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式:模糊查询
.withIgnoreCase(true); //改变默认大小写忽略方式:忽略大小写
User user = new User();
user.setName("三");
Example<User> userExample = Example.of(user, matcher);
List<User> userList = userRepository.findAll(userExample);
System.out.println(userList);
}
//分页查询
@Test
public void findUsersPage() {
Sort sort = Sort.by(Sort.Direction.DESC, "age");
//0为第一页
Pageable pageable = PageRequest.of(0, 10, sort);
//创建匹配器,即如何使用查询条件
ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
.withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式:模糊查询
.withIgnoreCase(true); //改变默认大小写忽略方式:忽略大小写
User user = new User();
user.setName("三");
Example<User> userExample = Example.of(user, matcher);
//创建实例
Example<User> example = Example.of(user, matcher);
Page<User> pages = userRepository.findAll(example, pageable);
System.out.println(pages);
}
//修改
@Test
public void updateUser() {
User user = userRepository.findById("5ffbfe8197f24a07007bd6ce").get();
user.setName("张三_1");
user.setAge(25);
user.setEmail("883220990@qq.com");
User save = userRepository.save(user);
System.out.println(save);
}
//删除
@Test
public void delete() {
userRepository.deleteById("5ffbfe8197f24a07007bd6ce");
}
}
RabbitMq和SpringBoot整合
记得相关的配置项可以写在一个微服务中,在使用的项目中依赖注入就行
第一步 :先注入依赖
<!--rabbitmq消息队列-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!--rabbitmq 协议-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
第二步: RabbitMq的相关配置
这写配置是关于Mq的消息成功(confirm)或失败(returnedMessage)的相关配置
/**
* @Description 消息发送确认
* @author: JC
* @date: 2021/11/10 18:46
* <p>
* ConfirmCallback 只确认消息是否正确到达 Exchange 中
* ReturnCallback 消息没有正确到达队列时触发回调,如果正确到达队列不执行
* <p>
* 1. 如果消息没有到exchange,则confirm回调,ack=false
* 2. 如果消息到达exchange,则confirm回调,ack=true
* 3. exchange到queue成功,则不回调return
* 4. exchange到queue失败,则回调return
*
*/
@Slf4j
@Component
public class MQProducerAckConfig implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnCallback{
@Autowired
private RabbitTemplate rabbitTemplate;
// 修饰一个非静态的void()方法,在服务器加载Servlet的时候运行,
// 并且只会被服务器执行一次在构造函数之后执行,init()方法之前执行。
@PostConstruct
public void init(){
rabbitTemplate.setConfirmCallback(this);
rabbitTemplate.setReturnCallback(this);
}
/**
* @param correlationData
* @param ack 消息是否发送成功
* @param cause 消息发送失败原因
* 修饰一个非静态的void()方法,在服务器加载Servlet的时候运行,
* 并且只会被服务器执行一次在构造函数之后执行,init()方法之前执行。
*/
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
if(ack){
// 消息成功发送到了交换机
System.out.println("消息发送成功");
}else{
// 消息发送失败
System.out.println("消息发送失败");
}
}
/**
* 表示消息没有发送成功 ,才会执行改方法
* @param message 应答码
* @param replyCode 应答码
* @param replyText 应答码对应的文本
* @param exchange 交换机
* @param routingKey 消息使用的路由键 routing
*/
@Override
public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
// 反序列化对象输出
System.out.println("消息主体: " + new String(message.getBody()));
System.out.println("应答码: " + replyCode);
System.out.println("描述:" + replyText);
System.out.println("消息使用的交换器 exchange : " + exchange);
System.out.println("消息使用的路由键 routing : " + routingKey);
}
}
第三步:在需要使用的项目中配置yaml
spring:
rabbitmq:
host: 192.168.179.128
port: 5672
username: guest
password: guest
publisher-confirms: true
publisher-returns: true
listener:
simple:
acknowledge-mode: manual #默认情况下消息消费者是自动确认消息的,如果要手动确认消息则需要修改确认模式为manual
prefetch: 1 # 消费者每次从队列获取的消息数量。此属性当不设置时为:轮询分发,设置为1为:公平分发
第四步:记得最好设置一个关于Rabbit的常量类(constant类似的的包)
public class MqConst {
/**
* 消息补偿
*/
public static final String MQ_KEY_PREFIX = "mq:list";
public static final int RETRY_COUNT = 3;
/**
* 商品上下架
*/
public static final String EXCHANGE_DIRECT_GOODS = "exchange.direct.goods";
public static final String ROUTING_GOODS_UPPER = "goods.upper";
public static final String ROUTING_GOODS_LOWER = "goods.lower";
//队列
public static final String QUEUE_GOODS_UPPER = "queue.goods.upper";
public static final String QUEUE_GOODS_LOWER = "queue.goods.lower";
/**
* 取消订单,发送延迟队列
*/
public static final String EXCHANGE_DIRECT_ORDER_CANCEL = "exchange.direct.order.cancel";//"exchange.direct.order.create" test_exchange;
public static final String ROUTING_ORDER_CANCEL = "order.create";
//延迟取消订单队列
public static final String QUEUE_ORDER_CANCEL = "queue.order.cancel";
//取消订单 延迟时间 单位:秒 真实业务
public static final int DELAY_TIME = 24*60*60;
/**
* 订单支付
*/
public static final String EXCHANGE_DIRECT_PAYMENT_PAY = "exchange.direct.payment.pay";
public static final String ROUTING_PAYMENT_PAY = "payment.pay";
//队列
public static final String QUEUE_PAYMENT_PAY = "queue.payment.pay";
/**
* 减库存
*/
public static final String EXCHANGE_DIRECT_WARE_STOCK = "exchange.direct.ware.stock";
public static final String ROUTING_WARE_STOCK = "ware.stock";
//队列
public static final String QUEUE_WARE_STOCK = "queue.ware.stock";
/**
* 减库存成功,更新订单状态
*/
public static final String EXCHANGE_DIRECT_WARE_ORDER = "exchange.direct.ware.order";
public static final String ROUTING_WARE_ORDER = "ware.order";
//队列
public static final String QUEUE_WARE_ORDER = "queue.ware.order";
/**
* 关闭交易
*/
public static final String EXCHANGE_DIRECT_PAYMENT_CLOSE = "exchange.direct.payment.close";
public static final String ROUTING_PAYMENT_CLOSE = "payment.close";
//队列
public static final String QUEUE_PAYMENT_CLOSE = "queue.payment.close";
/**
* 定时任务
*/
public static final String EXCHANGE_DIRECT_TASK = "exchange.direct.task";
public static final String ROUTING_TASK_1 = "seckill.task.1";
//队列
public static final String QUEUE_TASK_1 = "queue.task.1";
/**
* 秒杀
*/
public static final String EXCHANGE_DIRECT_SECKILL_USER = "exchange.direct.seckill.user";
public static final String ROUTING_SECKILL_USER = "seckill.user";
//队列
public static final String QUEUE_SECKILL_USER = "queue.seckill.user";
/**
* 定时任务
*/
public static final String ROUTING_TASK_18 = "seckill.task.18";
//队列
public static final String QUEUE_TASK_18 = "queue.task.18";
}
第五步:创建service 调用进行发送(有延迟消息和非延迟消息的区别)延迟还需要配置
@Service
public class RabbitService {
// 消息发送的方法
@Autowired
private RabbitTemplate rabbitTemplate;
/**
* 表示成功发送消息
* @param exchange
* @param routingKey
* @param message
* @return
*/
public boolean sendMessage(String exchange, String routingKey, Object message){
// 发送消息!
rabbitTemplate.convertAndSend(exchange,routingKey,message);
return true;
}
/**
* 发送延迟消息
* @param exchange 交换机
* @param routingKey 路由键
* @param message 消息
* @param delayTime 单位:秒
*/
public boolean sendDelayMessage(String exchange, String routingKey, Object message, int delayTime) {
this.rabbitTemplate.convertAndSend(exchange, routingKey, message, msg ->{
msg.getMessageProperties().setDelay(delayTime*1000);
return msg;
});
return true;
}
}
第六步 使用延迟消息 的配置(死信交换机)
消息延迟就是当超过多少时间就执行
本质就是用两条交换机(或说队列) 当主的TTL(存活时间过了)就让其执行第二个队列
然后不消费第一个队列的消息等其过期,我们监控第二个队列执行就行
消息延迟相关配置 (记得放config包中)
@Configuration
public class DeadLetterMqconfig {
// 定义变量:
public static final String EXCHANGE_DEAD = "exchange.dead";
public static final String ROUTING_DEAD_1 = "routing.dead.1";
public static final String ROUTING_DEAD_2 = "routing.dead.2";
public static final String QUEUE_DEAD_1 = "queue.dead.1";
public static final String QUEUE_DEAD_2 = "queue.dead.2";
// 定义交换机
@Bean
public DirectExchange exchange(){
return new DirectExchange(EXCHANGE_DEAD,true,false,null);
}
@Bean
public Queue queue1(){
// 设置如果队列一 出现问题,则通过参数转到exchange_dead,routing_dead_2 上!
HashMap<String, Object> map = new HashMap<>();
// 参数绑定 此处的key 固定值,不能随意写
map.put("x-dead-letter-exchange",EXCHANGE_DEAD);
map.put("x-dead-letter-routing-key",ROUTING_DEAD_2);
// 设置延迟时间
map.put("x-message-ttl", 10 * 1000);
// 队列名称,是否持久化,是否独享、排外的【true:只可以在本次连接中访问】,是否自动删除,队列的其他属性参数
return new Queue(QUEUE_DEAD_1,true,false,false,map);
}
@Bean
public Binding binding(){
// 将队列一 通过routing_dead_1 key 绑定到exchange_dead 交换机上
return BindingBuilder.bind(queue1()).to(exchange()).with(ROUTING_DEAD_1);
}
// 这个队列二就是一个普通队列
@Bean
public Queue queue2(){
return new Queue(QUEUE_DEAD_2,true,false,false,null);
}
// 设置队列二的绑定规则
@Bean
public Binding binding2(){
// 将队列二通过routing_dead_2 key 绑定到exchange_dead交换机上!
return BindingBuilder.bind(queue2()).to(exchange()).with(ROUTING_DEAD_2);
}
}
// 监听获取消息! 需要设置绑定参数
// @RabbitListener()
@RabbitListener(bindings = @QueueBinding(
value = @Queue(value = "queue.confirm",durable = "true", autoDelete = "false"),
exchange = @Exchange(value = "exchange.confirm",durable = "true", autoDelete = "false"),
key= {"routing.confirm"}
))
@SneakyThrows
public void getMsg(String msg, Message message, Channel channel){
long deliveryTag = 0;
try {
System.out.println("获取的消息:"+msg);
System.out.println("获取的消息(Message):"+new String(message.getBody()));
// 手动确认 : ack
deliveryTag = message.getMessageProperties().getDeliveryTag();
// false: 表示一个一个来确认消息 ,true表示批量确认消息!
channel.basicAck(deliveryTag,false);
} catch (IOException e) {
log.info("rabbitMq监听失败原因:"+e.getMessage());
// 第三个参数:是否重回队列
channel.basicNack(deliveryTag,false,true);
} finally {
}
}
第七步:监听rabbitMq进行消费
非消息延迟的监听
@Component
public class ListReceiver {
@Autowired
private SearchService searchService;
/**
* 实现商品上架(es 中上架)
* @param skuId
* @param message
* @param channel
*/
@RabbitListener(
bindings = @QueueBinding(
value = @Queue(value = MqConst.QUEUE_GOODS_UPPER,durable = "true",autoDelete = "false"),
exchange = @Exchange(value = MqConst.EXCHANGE_DIRECT_GOODS,durable = "true", autoDelete = "false"),
key = MqConst.ROUTING_GOODS_UPPER
)
)
@SneakyThrows
public void upperGoodsListener(Long skuId, Message message, Channel channel){
// 有消息
if(skuId != null){
// 实现上架
searchService.upperGoods(skuId);
}
// 消息确认
long deliveryTag = message.getMessageProperties().getDeliveryTag();
// false: 表示一个一个来确认消息 ,true表示批量确认消息!
channel.basicAck(deliveryTag,false);
// 第三个参数:是否重回队列
}
/**
* 实现商品上架(es 中下架)
* @param skuId
* @param message
* @param channel
*/
@RabbitListener(
bindings = @QueueBinding(
value = @Queue(value = MqConst.QUEUE_GOODS_UPPER,durable = "true",autoDelete = "false"),
exchange = @Exchange(value = MqConst.EXCHANGE_DIRECT_GOODS,durable = "true", autoDelete = "false"),
key = MqConst.ROUTING_GOODS_LOWER
)
)
@SneakyThrows
public void lowerGoodsListener(Long skuId, Message message, Channel channel){
// 有消息
if(skuId != null){
// 实现上架
searchService.lowerGoods(skuId);
}
// 消息确认
long deliveryTag = message.getMessageProperties().getDeliveryTag();
// false: 表示一个一个来确认消息 ,true表示批量确认消息!
channel.basicAck(deliveryTag,false);
}
}
消息延迟的监听(监听方法的第一个参数根据对应传入值的类)
@Component
public class OrderReceiver {
@Autowired
private OrderService orderService;
// 监听的消息
@SneakyThrows
@RabbitListener(queues = MqConst.QUEUE_ORDER_CANCEL)
public void cancelOrder(Long orderId , Message message, Channel channel){
// 判断当前订单Id 不能为空
try {
if (orderId!=null){
// 发过来的是订单Id,那么你就需要判断一下当前的订单是否已经支付了。
// 未支付的情况下:关闭订单
// 根据订单Id 查询orderInfo select * from order_info where id = orderId
// 利用这个接口IService 实现类ServiceImpl 完成根据订单Id 查询订单信息 ServiceImpl 类底层还是使用的mapper
OrderInfo orderInfo = orderService.getById(orderId);
// 判断支付状态,进度状态
if (orderInfo!=null && "UNPAID".equals(orderInfo.getOrderStatus())
&& "UNPAID".equals(orderInfo.getProcessStatus())){
// 关闭订单
// int i = 1/0;
orderService.execExpiredOrder(orderId);
}
}
} catch (Exception e) {
// 消息没有正常被消费者处理:
// 第一个参数就是long 标识, 第二个参数表示 是否批量确认 ,第三个参数是否重回队列
channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,true);
// 发短信的形式通知我们的管理员,立刻查看并解决问题 类似于消息的积压!
// 如果线上真的出现了这种问题,你能停止这个微服务改代码? 跟我刚刚的操作类似,启动一个其他的程序消费这个消息!
e.printStackTrace();
}
// 手动确认消息 如果不确认,有可能会到消息残留。
channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
}
}