开源 / Spring / 使用小结
8 分钟 读完 (大约 1268 个字)

180623-SpringBoot之logback配置文件

SpringBoot配置logback

项目的日志配置属于比较常见的case了，之前接触和使用的都是Spring结合xml的方式，引入几个依赖，然后写个 logback.xml 配置文件即可，那么在SpringBoot中可以怎么做？

阅读更多
开源 / Yaml
8 分钟 读完 (大约 1197 个字)

180619-Yaml文件语法及读写小结

Yaml文件小结

Yaml文件有自己独立的语法，常用作配置文件使用，相比较于xml和json而言，减少很多不必要的标签或者括号，阅读也更加清晰简单；本篇主要介绍下YAML文件的基本语法，以及如何在Java中实现读写逻辑

阅读更多
开源 / Guava
4 分钟 读完 (大约 585 个字)

180613-GuavaCache返回Null的注意事项

GuavaCache返回Null的注意事项

Guava在实际的Java后端项目中应用的场景还是比较多的，比如限流，缓存，容器操作之类的，有挺多实用的工具类，这里记录一下，在使用GuavaCache，返回null的一个问题

I. 常见使用姿势

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public void testGuava() {
    LoadingCache<String, String> cache = CacheBuilder.newBuilder().build(new CacheLoader<String, String>() {
        @Override
        public String load(String key) throws Exception {
            if ("hello".equals(key)) {
                return "word";
            }
            return null;
        }
    });

    String word = cache.getUnchecked("hello");
    System.out.println(word);

    System.out.println(cache.getUnchecked("word"));
}

上面是一个非常简单的测试case，需要注意的是，cache.get("word") 的执行，并不如逾期的返回的是null，而是会抛一个异常出来

1
2
3
4
word
com.google.common.cache.CacheLoader$InvalidCacheLoadException: CacheLoader returned null for key word.
	at com.google.common.cache.LocalCache$Segment.getAndRecordStats(LocalCache.java:2287)
...

从异常描述能看出，不允许返回null，这一块之前倒是没怎么注意，因此对于null的情况，要么定义一个标记表示不存在，要么在load()方法中主动抛一个异常出来，在使用的时候注意下，通过异常的使用方式，可以如下

1
2
3
4
5
6
7
8
9
10
public class NoVlaInGauvaException extends Exception {
    public NoVlaInGauvaException(String msg) {
        super(msg);
    }

    @Override
    public synchronized Throwable fillInStackTrace() {
        return this;
    }
}

说明：为什么重写fillInStackTrace方法

  • 对于这种缓存未命中的情况下，一般而言是不需要关注完整的堆栈信息的，没有数据而已，可以节省一点点性能（当然除非是在高频率的抛出时，才会有表现症状）

其次就是get与getUnchecked的区别了

  • get要求显示处理exception状况
  • getUnchecked 一般是可确认不会有问题的场景，直接调用

II. 其他

1. 一灰灰Blog： https://liuyueyi.github.io/hexblog

一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

2. 声明

尽信书则不如，已上内容，纯属一家之言，因个人能力有限，难免有疏漏和错误之处，如发现bug或者有更好的建议，欢迎批评指正，不吝感激

3. 扫描关注

QrCode

开源 / Spring / 使用小结
2 分钟 读完 (大约 362 个字)

180612-Spring之Yml配置文件加载问题

Yml配置文件加载问题

在resource目录下有一个application.yml文件，希望是通过@PropertySource注解，将配置文件数据读取到Environment中，然而调试发现数据始终读取不到，google之后，记录下解决方法

在测试用例中，指定初始化方式 @ContextConfiguration(classes = RedisConf.class, initializers = ConfigFileApplicationContextInitializer.class)

1
2
3
4
5
6
7
8
9
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = RedisConf.class, initializers = ConfigFileApplicationContextInitializer.class)
public class RedisTest {
    @Test
    public void testRedis() {
        String ans = JedisClient.getStr("hello");
        System.out.println(ans);
    }
}

对应的配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@Configuration
@PropertySource(value = "classpath:application.yml")
public class RedisConf {

    @Autowired
    private Environment environment;

    @Autowired
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        DefaultStrSerializer serializer = new DefaultStrSerializer();
        redisTemplate.setValueSerializer(serializer);
        redisTemplate.setHashValueSerializer(serializer);
        redisTemplate.setKeySerializer(serializer);
        redisTemplate.setHashKeySerializer(serializer);

        redisTemplate.afterPropertiesSet();

        JedisClient.register(redisTemplate);
        return redisTemplate;
    }

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        LettuceConnectionFactory fac = new LettuceConnectionFactory();
        fac.getStandaloneConfiguration().setHostName(environment.getProperty("spring.redis.host"));
        fac.getStandaloneConfiguration().setPort(Integer.parseInt(environment.getProperty("spring.redis.port")));
        fac.getStandaloneConfiguration()
                .setPassword(RedisPassword.of(environment.getProperty("spring.redis.password")));
        fac.afterPropertiesSet();
        return fac;
    }
}

II. 其他

1. 一灰灰Blog： https://liuyueyi.github.io/hexblog

一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

2. 声明

尽信书则不如，已上内容，纯属一家之言，因个人能力有限，难免有疏漏和错误之处，如发现bug或者有更好的建议，欢迎批评指正，不吝感激

3. 扫描关注

QrCode

开源 / Spring / 使用小结
13 分钟 读完 (大约 1966 个字)

180611-Spring之RedisTemplate配置与使用

Spring之RedisTemplate配置与使用

Spring针对Redis的使用，封装了一个比较强大的Template以方便使用；之前在Spring的生态圈中也使用过redis，但直接使用Jedis进行相应的交互操作，现在正好来看一下RedisTemplate是怎么实现的，以及使用起来是否更加便利

阅读更多
开源 / Spring / 使用小结
7 分钟 读完 (大约 1032 个字)

180609-Spring之事件驱动机制的简单使用

Spring之事件驱动机制的简单使用

关于事件的发起与相应，在客户端的交互中可算是非常频繁的事情了，关于事件的发布订阅，在Java生态中，EventBus可谓是非常有名了，而Spring也提供了事件机制，本文则主要介绍后端如何在Spring的环境中，使用事件机制

阅读更多
开源 / RabbitMQ
12 分钟 读完 (大约 1780 个字)

RabbitMQ基础教程之基于配置的消费者实现

RabbitMQ基础教程之基于配置的消费者实现

相关博文，推荐查看:

  1. RabbitMq基础教程之安装与测试
  2. RabbitMq基础教程之基本概念
  3. RabbitMQ基础教程之基本使用篇
  4. RabbitMQ基础教程之使用进阶篇
  5. RabbitMQ基础教程之Spring&JavaConfig使用篇
  6. RabbitMQ基础教程之Spring-JavaConfig-FactoryBean使用姿势

前面一篇介绍了使用工厂方式创建消费者，其中一个不太友好的地方就在配置都是硬编码的方式，不太灵活，那么是否可以结合前一篇的FactoryBean来实现从配置中来灵活的创建消费者呢？

阅读更多
开源 / RabbitMQ
14 分钟 读完 (大约 2083 个字)

RabbitMQ基础教程之Spring&JavaConfig&FactoryBean使用姿势

RabbitMQ基础教程之Spring使用篇

相关博文，推荐查看:

  1. RabbitMq基础教程之安装与测试
  2. RabbitMq基础教程之基本概念
  3. RabbitMQ基础教程之基本使用篇
  4. RabbitMQ基础教程之使用进阶篇
  5. RabbitMQ基础教程之Spring&JavaConfig使用篇

在前面的一篇演示了如何使用Spring来进行RabbitMQ的消息投递和消费，虽然可以实现基本的需求场景，但是使用起来却并不是特别顺手，首先是不同的消费者，得添加好多不同的配置项，加上有较多的配置（QueueName, ExchangeName, RoutingKey, autoAck…)

那么有没有可能借助工厂方式，来简化消费者这边的大多数配置呢？

阅读更多
开源 / RabbitMQ
12 分钟 读完 (大约 1812 个字)

RabbitMQ基础教程之Spring&JavaConfig使用篇

RabbitMQ基础教程之Spring使用篇

相关博文，推荐查看:

  1. RabbitMq基础教程之安装与测试
  2. RabbitMq基础教程之基本概念
  3. RabbitMQ基础教程之基本使用篇
  4. RabbitMQ基础教程之使用进阶篇

在实际的应用场景中，将RabbitMQ和Spring结合起来使用的时候可能更加频繁，网上关于Spring结合的博文中，大多都是xml的方式，这篇博文，则主要介绍下利用JavaConfig的结合，又会是怎样的

阅读更多
开源 / Spring / 使用小结
13 分钟 读完 (大约 1929 个字)

180531-Spring中JavaConfig知识小结

Sring中JavaConfig使用姿势

去掉xml的配置方式，改成用Java来配置，最常见的就是将xml中的 bean定义， scanner包扫描，属性文件的配置信息读取等

I. 几个基本注解

1. Configuration注解

在javaConfig中注解@Configuration用来代替一个xml文件，可以简单的理解他们的作用是相等的，一般bean的定义也都是放在被这个注解修饰的类中

如一个基本的配置文件如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Configuration
@ComponentScan("com.git.hui.rabbit.spring")
public class SpringConfig {
    private Environment environment;

    @Autowired
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        System.out.println("then env: " + environment);
    }

    @Bean(name="connectionFactory")
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory factory = new CachingConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("admin");
        factory.setVirtualHost("/");
        return factory;
    }

    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }
}

2. Bean 注解

上面的例子中，在方法上添加了@Bean注解，这个就相当于传统的

1
<bean name="rabbitAdmin" class="org.springframework.amqp.rabbit.core.RabbitAdmin"/>

因此在需要引入rabbitAdmin实例的地方，可以如下使用

a. 属性字段上添加 @Autowired注解

1
2
3
4
public class RConsumer {
  @Autowired
  private RabbitAdmin rabbitAdmin;
}

b. 设置方法上添加 @Autowired注解

1
2
3
4
5
6
7
8
public class RConsumer {
  private RabbitAdmin rabbitAdmin;
  
  @Autowired
  public void setRabbitAdmin(RabbitAdmin rabbitAdmin) {
    this.rabbitAdmin = rabbitAdmin;
  }
}

c. 使用构造器的方式

1
2
3
4
5
6
public class RConsumer {
  private RabbitAdmin rabbitAdmin;
  public RConsumer(RabbitAdmin rabbitAdmin) {
        this.rabbitAdmin = rabbitAdmin;
  }
}

上面就是Spring容器支持的几种典型的IoC方式

3. ComponentScan

这个类似于xml中的 <context:component-scan"/> 标签

1
2
3
@ComponentScan("com.git.hui.rabbit.spring")
public class SpringConfig {
}

上面的这个配置，表示自动扫描包 com.git.hui.rabbit.spring 下面的bean （要求类上添加了 @Component, @Repository, @Service）

那么一个问题来了，如果一个类既被自动扫描加载，又显示定义了bean，会怎样?

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.git.hui.rabbit.spring;

import org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicInteger;

@Component
public class TestBean {
    private static AtomicInteger count = new AtomicInteger(1);

    public TestBean() {
        System.out.println("testBean count: " + count.getAndAdd(1));
    }
}

对应的JavaConfig

1
2
3
4
5
6
7
8
@Configuration
@ComponentScan("com.git.hui.rabbit.spring")
public class SpringConfig {
    @Bean
    public TestBean testBean() {
        return new TestBean();
    }
}

实际测试，发现这个bean只会有一个实例，即输出计数只会有一条，实际查看ApplicationContext中的内容，TestBean的实例，也确实只有一个，如果改成下面这种场景呢

1
2
3
4
@Bean(name="testBean2")
public TestBean testBean() {
    return new TestBean();
}

会有两条记录输出，实际查看容器中的Bean对象,会有两个实例如下

image1

这和我们的预期也是一样的，因为一个类我可能需要多个不同的Bean实例来干一些事情

那么出现这种JavaConfig定义的beanName与自动扫描的冲突的情况会怎样呢？

新增一个NewBean对象，

1
2
3
4
5
6
7
public class NewBean {
    private static AtomicInteger count = new AtomicInteger(1);

    public NewBean() {
        System.out.println(" newbean count: " + count.getAndAdd(1));
    }
}

在JavaConfig中新加一个bean定义，但是BeanName与自动扫描的TestBean重复了

1
2
3
4
@Bean(name="testBean")
public NewBean newBean() {
  return new NewBean();
}

此时发现有意思的事情了，从Spring容器中，将查不到TestBean的实例，但是可以查到NewBean的实例

image1

这个的表现是：

  • 当beanName出现冲突时，JavaConfig的优先级会高于自动加载的，导致自动加载的Bean不会被加载到容器内

那么跟着来的一个问题就是如果JavaConfig中定义了两个相同的BeanName的bean呢?

1
2
3
4
5
6
7
8
9
@Bean(name = "testBean2")
public NewBean newBean() {
    return new NewBean();
}

@Bean(name = "testBean2")
public TestBean testBean() {
    return new TestBean();
}

因为我们TestBean上加了@Component注解,因此容器中至少有一个，但是否会有testBean2这个实例呢？ 通过实际查看是没有的，testBean2这个名被 NewBean 占领了

image1

so，表现上看，加上实测，将上面的定义换个位置，得出下面的结论

  • 当出现beanName重名时，先定义的Bean占优

然后就是最后一个问题了，当自动扫描时，两个类包不同，但是类名相同，会怎样？

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.git.hui.rabbit.spring.demo;

import org.springframework.stereotype.Component;
import java.util.concurrent.atomic.AtomicInteger;

@Component
public class TestBean {
    private static AtomicInteger count = new AtomicInteger(1);

    public TestBean() {
        System.out.println(" demo.TestBean count: " + count.getAndAdd(1));
    }
}

实测，会抛出一个异常，在使用xml的配置方式时，经常见到的一个BeanName冲突的异常

1
org.springframework.context.annotation.ConflictingBeanDefinitionException: Annotation-specified bean name 'testBean' for bean class [com.git.hui.rabbit.spring.demo.TestBean] conflicts with existing, non-compatible bean definition of same name and class [com.git.hui.rabbit.spring.TestBean]

小结：

  • JavaConfig 定义的BeanName与自动扫描的BeanName冲突时，JavaConfig的定义的会被实例化
  • JavaConfig 中定义了BeanName相同的Bean时，优先定义的有效（这里不抛异常不太能理解）
  • 自动扫描的Bean，不支持类名相同，但是包路径不同的场景（会抛异常）

4. Import

在xml配置中，另一个常见的case就是引入另一个xml配置，在JavaConfig中代替的就是Import注解

1
2
3
4
5
@Configuration
@ComponentScan("com.git.hui.rabbit.spring")
@Import({DirectConsumerConfig.class, FanoutConsumerConfig.class, TopicConsumerConfig.class})
public class SpringConfig {
}

这个就等同于xml中常见的：

1
<import resource="service.xml" />

II. 实例测试

1. xml单测姿势

上面说了用JavaConfig代替xml配置的方式，另一个关键的地方就是测试用例的写法了，对于之前的xml，有两种常见的使用姿势

case1: 注解方式

1
2
3
4
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath*:*.xml")
public class BeanTest {
}

case2: 主动加载容器方式

1
2
3
4
5
6
7
private ServiceA serviceA;

@Before
public void init() {
    ApplicationContext apc = new ClassPathXmlApplicationContext("classpath:*.xml");
    serviceA = (ServiceA) apc.getBean("serviceA");
}

2. JavaConfig单测使用姿势

那么替换成JavaConfig的用法，也有两种

case1: 注解方式，指定内部classes值

1
2
3
4
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class SprintUnit {
}

case2: 主动加载容器，改为AnnotationConfigApplicationContext

1
2
3
4
5
6
@Test
public void testServiceA() {
    ApplicationContext context = new AnnotationConfigApplicationContext(BeansConfiguration.class);
    ServiceA serviceA = (ServiceA) context.getBean("serviceA");
    serviceA.print();
}

III. 小结

1. 注解映射关系

JavaConfig方式基本上采用的是替换的思路来取代xml，即原xml中的一些东西，可以直接通过注解来代替，如

  • @Configuration 修饰类，与传统的xml文件作用相同
  • @Bean注解，修饰方法，表示声明一个Bean，与原来的xml中的 <bean> 标签作用相同
  • @ComponentScan注解，自动扫描包，类似xml中的 <context:component-scan>
  • @Import注解，与xml中的<import>标签类似，引入其他的配置信息

2. BeanName重名规则

在实际使用中，有一点需要额外注意，对于beanName相同的情况，通过测试的规则如下（没有看源码，不保证完全准确，仅为测试后得出的依据）：

  • JavaConfig 定义的BeanName与自动扫描的BeanName冲突时，JavaConfig的定义的会被实例化
  • JavaConfig 中定义了BeanName相同的Bean时，优先定义的有效（这里不抛异常不太能理解）
  • 自动扫描的Bean，不支持类名相同，但是包路径不同的场景（会抛异常）

3. 测试姿势

最简单的就是修改原来的注解@ContextConfiguration中的值

1
@ContextConfiguration(classes = SpringConfig.class)

II. 其他

一灰灰Blog： https://liuyueyi.github.io/hexblog

一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

声明

尽信书则不如，已上内容，纯属一家之言，因个人能力有限，难免有疏漏和错误之处，如发现bug或者有更好的建议，欢迎批评指正，不吝感激

扫描关注

QrCode

开源 / RabbitMQ
14 分钟 读完 (大约 2158 个字)

RabbitMQ基础教程之使用进阶篇

RabbitMQ基础教程之使用进阶篇

相关博文，推荐查看:

  1. RabbitMq基础教程之安装与测试
  2. RabbitMq基础教程之基本概念
  3. RabbitMQ基础教程之基本使用篇

I. 背景

前一篇基本使用篇的博文中，介绍了rabbitmq的三种使用姿势，可以知道如何向RabbitMQ发送消息以及如何消费，但遗留下几个疑问，本篇则主要希望弄清楚这几点

  • Exchange声明的问题（是否必须声明，如果不声明会怎样）
  • Exchange声明的几个参数（durable, autoDelete)有啥区别
  • 当没有队列和Exchange绑定时，直接往队列中塞数据，好像不会有数据增加（即先塞数据，然后创建queue，建立绑定，从控制台上看这个queue里面也不会有数据）
  • 消息消费的两种姿势（一个主动去拿数据，一个是rabbit推数据）对比
阅读更多
开源 / RabbitMQ
17 分钟 读完 (大约 2485 个字)

RabbitMQ基础教程之基本使用篇

RabbitMQ基础教程之基本使用篇

最近因为工作原因使用到RabbitMQ，之前也接触过其他的mq消息中间件，从实际使用感觉来看，却不太一样，正好趁着周末，可以好好看一下RabbitMQ的相关知识点；希望可以通过一些学习，可以搞清楚以下几点

  • 基础环境搭建
  • 可以怎么使用
  • 实现原理是怎样的
  • 实际工程中的使用（比如结合SpringBoot可以怎么玩）
阅读更多
开源 / RabbitMQ
18 分钟 读完 (大约 2659 个字)

RabbitMq基础教程之基本概念

RabbitMq基础教程之基本概念

RabbitMQ是一个消息队列，和Kafka以及阿里的ActiveMQ从属性来讲，干的都是一回事。消息队列的主要目的实现消息的生产者和消费者之间的解耦，支持多应用之间的异步协调工作

由于工作原因，接触和使用rabbitmq作为生产环境下的消息队列，因此准备写一些博文，记录下这个过程中的收货；而开篇除了环境搭建之外，就是对于其内部的基本概念进行熟悉和了解了。

基础环境搭建可以参考： 《RabbitMq基础教程之安装与测试》

本文则主要集中在以下几点：

  • 几个基本概念（Message, Publisher, Exchange, Binding, Queue, Channel, Consuer, Virtual host)
  • 消息分发的几种策略
  • ACK是什么鬼
阅读更多
开源 / RabbitMQ
6 分钟 读完 (大约 959 个字)

RabbitMq基础教程之安装与测试

RabbitMq基础教程之安装与测试

Installing on Mac

I. 安装

1
2
3
4
5
6
7
8
9
brew install rabbitmq

## 进入安装目录
cd /usr/local/Cellar/rabbitmq/3.7.5

# 启动
brew services start rabbitmq
# 当前窗口启动
rabbitmq-server
阅读更多
开源 / Spring / 使用小结
17 分钟 读完 (大约 2618 个字)

Spring学习之事务管理与传播属性

Spring 事务管理与传播属性

在博文 《Spring学习之事务的使用姿势》 中，演示了基于注解和xml的事务使用姿势，以@Transactional注解为例，其中很多的参数都没有详细说明

本篇博文，则主要目的是弄懂这些参数有啥用，以及在实际项目中如何选择

阅读更多
开源 / Spring / 使用小结
27 分钟 读完 (大约 4026 个字)

Spring学习之事务的使用姿势

Spring + mybatis + mysql 使用事务的几种姿势

主要记录下spring是如何支持事务的，以及在Spring结合mybatis时，可以怎么简单的实现数据库的事务功能

I. 前提

case1：两张表的的事务支持情况

首先准备两张表，一个user表，一个story表，结构如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
CREATE TABLE `user` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL DEFAULT '' COMMENT '用户名',
  `pwd` varchar(26) NOT NULL DEFAULT '' COMMENT '密码',
  `isDeleted` tinyint(1) NOT NULL DEFAULT '0',
  `created` varchar(13) NOT NULL DEFAULT '0',
  `updated` varchar(13) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`),
  KEY `name` (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `story` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `userId` int(20) unsigned NOT NULL DEFAULT '0' COMMENT '作者的userID',
  `name` varchar(20) NOT NULL DEFAULT '' COMMENT '作者名',
  `title` varchar(26) NOT NULL DEFAULT '' COMMENT '密码',
  `story` text COMMENT '故事内容',
  `isDeleted` tinyint(1) NOT NULL DEFAULT '0',
  `created` varchar(13) NOT NULL DEFAULT '0',
  `updated` varchar(13) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`),
  KEY `userId` (`userId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

我们的事务场景在于用户修改name时，要求两张表的name都需要一起修改，不允许出现不一致的情况

case2：单表的事务支持

转账，一个用户减钱，另一个用户加钱

1
2
3
4
5
6
7
8
9
10
CREATE TABLE `money` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL DEFAULT '' COMMENT '用户名',
  `money` int(26) NOT NULL DEFAULT '0' COMMENT '钱',
  `isDeleted` tinyint(1) NOT NULL DEFAULT '0',
  `created` varchar(13) NOT NULL DEFAULT '0',
  `updated` varchar(13) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`),
  KEY `name` (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

相比上面那个case，这个更加简单了，下面的实例则主要根据这个进行说明，至于case1，则留待扩展里面进行

首先是实现对应的dao和entity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Data
public class MoneyEntity implements Serializable {

    private static final long serialVersionUID = -7074788842783160025L;

    private int id;

    private String name;

    private int money;

    private int isDeleted;

    private int created;

    private int updated;
}


public interface MoneyDao {
    MoneyEntity queryMoney(@Param("id") int userId);

    // 加钱，负数时表示减钱
    int incrementMoney(@Param("id") int userId, @Param("addMoney") int addMoney);
}

对应的mapper文件为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?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.git.hui.demo.mybatis.mapper.MoneyDao">

    <sql id="moneyEntity">
        id, `name`, `money`, `isDeleted`, `created`, `updated`
    </sql>


    <select id="queryMoney" resultType="com.git.hui.demo.mybatis.entity.MoneyEntity">
        select
        <include refid="moneyEntity"/>
        from money
        where id=#{id}

    </select>

    <update id="incrementMoney">
        update money
        set money=money + #{addMoney}
        where id=#{id}
    </update>
</mapper>

对应的mybatis连接数据源的相关配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <value>classpath*:jdbc.properties</value>
    </property>
</bean>


<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
    <property name="driverClassName" value="${driver}"/>
    <property name="url" value="${url}"/>
    <property name="username" value="${username}"/>
    <property name="password" value="${password}"/>

    <property name="filters" value="stat"/>

    <property name="maxActive" value="20"/>
    <property name="initialSize" value="1"/>
    <property name="maxWait" value="60000"/>
    <property name="minIdle" value="1"/>

    <property name="timeBetweenEvictionRunsMillis" value="60000"/>
    <property name="minEvictableIdleTimeMillis" value="300000"/>

    <property name="validationQuery" value="SELECT 'x'"/>
    <property name="testWhileIdle" value="true"/>
    <property name="testOnBorrow" value="false"/>
    <property name="testOnReturn" value="false"/>

    <property name="poolPreparedStatements" value="true"/>
    <property name="maxPoolPreparedStatementPerConnectionSize" value="50"/>
</bean>


<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!-- 指定mapper文件 -->
    <property name="mapperLocations" value="classpath*:mapper/*.xml"/>
</bean>


<!-- 指定扫描dao -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.git.hui.demo.mybatis"/>
</bean>

II. 实例演示

通过网上查询，Spring事务管理总共有四种方式，下面逐一进行演示，每种方式是怎么玩的，然后看实际项目中应该如何抉择

1. 硬编码方式

编程式事务管理，既通过TransactionTemplate来实现多个db操作的事务管理

a. 实现

那么，我们的转账case可以如下实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@Repository
public class CodeDemo1 {

    @Autowired
    private MoneyDao moneyDao;


    @Autowired
    private TransactionTemplate transactionTemplate;


    /**
     * 转账
     *
     * @param inUserId
     * @param outUserId
     * @param payMoney
     * @param status    0 表示正常转账， 1 表示内部抛出一个异常， 2 表示新开一个线程，修改inUserId的钱 +200， 3 表示新开一个线程，修改outUserId的钱 + 200
     */
    public void transfor(final int inUserId, final int outUserId, final int payMoney, final int status) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
                MoneyEntity entity = moneyDao.queryMoney(outUserId);
                if (entity.getMoney() > payMoney) { // 可以转账

                    // 先减钱
                    moneyDao.incrementMoney(outUserId, -payMoney);

                    
                    testCase(inUserId, outUserId, status);

                    // 再加钱
                    moneyDao.incrementMoney(inUserId, payMoney);
                    System.out.println("转账完成! now: " + System.currentTimeMillis());
                }
            }
        });
    }
    
    
    // 下面都是测试用例相关
    private void testCase(final int inUserId, final int outUserId, final int status) {
        if (status == 1) {
            throw new IllegalArgumentException("转账异常!!!");
        } else if(status == 2) {
            addMoney(inUserId);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else if (status == 3) {
            addMoney(outUserId);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    public void addMoney(final int userId) {
        System.out.printf("内部加钱: " + System.currentTimeMillis());
        new Thread(new Runnable() {
            public void run() {
                moneyDao.incrementMoney(userId, 200);
                System.out.println("  sub modify success! now: " + System.currentTimeMillis());
            }
        }).start();
    }
}

主要看上面的transfor方法，内部通过 transactionTemplate 来实现事务的封装，内部有三个db操作，一个查询，两个更新，具体分析后面说明

上面的代码比较简单了，唯一需要关注的就是transactionTemplate这个bean如何定义的，xml文件中与前面重复的就不贴了，直接贴上关键代码, 一个是根据DataSource创建的TransactionManager，一个则是根据TransactionManager创建的TransactionTemplate

1
2
3
4
5
6
7
8
<!--编程式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
    <property name="transactionManager" ref="transactionManager"/>
</bean>

b. 测试用例

正常演示情况, 演示没有任何异常，不考虑并发的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath*:spring/service.xml", "classpath*:test-datasource1.xml"})
public class CodeDemo1Test {
    @Autowired
    private CodeDemo1 codeDemo1;

    @Autowired
    private MoneyDao moneyDao;

    @Test
    public void testTransfor() {

        System.out.println("---------before----------");
        System.out.println("id: 1 money = " + moneyDao.queryMoney(1).getMoney());
        System.out.println("id: 2 money = " + moneyDao.queryMoney(2).getMoney());


        codeDemo1.transfor(1, 2, 10, 0);

        System.out.println("---------after----------");
        System.out.println("id: 1 money = " + moneyDao.queryMoney(1).getMoney());
        System.out.println("id: 2 money = " + moneyDao.queryMoney(2).getMoney());
    }
}

输出如下，两个账号的钱都没有问题

1
2
3
4
5
6
7
---------before----------
id: 1 money = 10000
id: 2 money = 50000
转账完成! now: 1526130394266
---------after----------
id: 1 money = 10010
id: 2 money = 49990

转账过程中出现异常，特别是转账方钱已扣，收款方还没收到钱时，也就是case中的status为1的场景

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 内部抛异常的情况
@Test
public void testTransforException() {

    System.out.println("---------before----------");
    System.out.println("id: 1 money = " + moneyDao.queryMoney(1).getMoney());
    System.out.println("id: 2 money = " + moneyDao.queryMoney(2).getMoney());


    try {
        codeDemo1.transfor(1, 2, 10, 1);
    } catch (Exception e) {
        e.printStackTrace();
    }

    System.out.println("---------after----------");
    System.out.println("id: 1 money = " + moneyDao.queryMoney(1).getMoney());
    System.out.println("id: 2 money = " + moneyDao.queryMoney(2).getMoney());
}

对此，我们希望把转账方的钱还回去, 输出如下，发现两个的钱都没有变化

1
2
3
4
5
6
7
8
---------before----------
id: 1 money = 10010
id: 2 money = 49990
---------after----------
id: 1 money = 10010
java.lang.IllegalArgumentException: 转账异常!!!
	... // 省略异常信息
id: 2 money = 49990

当status为2，表示在转账人钱已扣，收款人钱没收到之间，又有人给收款人转了200，此时根据mysql的锁机制，另外人的转账应该是立马到的（因为收款人账号没有被锁住），且金额不应该有问题

输出结果如下：

1
2
3
4
5
6
7
8
9
10
11
---------before----------
id: 1 money = 10010
id: 2 money = 49990
## 右边是注释: 转账过程中，另外存钱立马到账，没有被锁住
内部加钱: 1526130827480
sub modify success! now: 1526130827500 
## 存钱结束
转账完成! now: 1526130830488
---------after----------
id: 1 money = 10220
id: 2 money = 49980

当status为3， 表示在转账人钱已扣，收款人钱没收到之间，又有人给转账人转了200，这时因为转账人的记录以及被加了写锁，因此只能等待转账的事务提交之后，才有可能+200成功，当然最终的金额也得一致

输出结果如下

1
2
3
4
5
6
7
8
9
10
11
---------before----------
id: 1 money = 10220
id: 2 money = 49980
## 右边是注释：内部存钱了，但没有马上成功
## 直到转账完成后，才立马存成功，注意两个时间戳
内部加钱: 1526131101046
转账完成! now: 1526131104051
sub modify success! now: 1526131104053
---------after----------
id: 1 money = 10230
id: 2 money = 50170

c. 小结

至此，编程式事务已经实例演示ok，从上面的过程，给人的感觉就和直接写事务相关的sql一样，

1
2
3
4
5
6
start transaction;

-- 这中间就是 TransactionTemplate#execute 方法内部的逻辑
-- 也就是需要事务管理的一组sql

commit;

2. 基于TransactionProxyFactoryBean方式

接下来的三个就是声明式事务管理，这种用得也比较少，因为需要每个事务管理类，添加一个TransactionProxyFactoryBean

a. 实现

除了将 TransactionTemplate 干掉，并将内部的sql逻辑移除之外，对比前面的，发现基本上没有太多差别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public class FactoryBeanDemo2 {

    @Autowired
    private MoneyDao moneyDao;

    /**
     * 转账
     *
     * @param inUserId
     * @param outUserId
     * @param payMoney
     * @param status    0 表示正常转账， 1 表示内部抛出一个异常， 2 表示新开一个线程，修改inUserId的钱 +200， 3 表示新开一个线程，修改outUserId的钱 + 200
     */
    public void transfor(final int inUserId, final int outUserId, final int payMoney, final int status) {

        MoneyEntity entity = moneyDao.queryMoney(outUserId);
        if (entity.getMoney() > payMoney) { // 可以转账

            // 先减钱
            moneyDao.incrementMoney(outUserId, -payMoney);


            testCase(inUserId, outUserId, status);


            // 再加钱
            moneyDao.incrementMoney(inUserId, payMoney);
            System.out.println("转账完成! now: " + System.currentTimeMillis());
        }


    }


    private void testCase(final int inUserId, final int outUserId, final int status) {
        if (status == 1) {
            throw new IllegalArgumentException("转账异常!!!");
        } else if (status == 2) {
            addMoney(inUserId);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else if (status == 3) {
            addMoney(outUserId);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    public void addMoney(final int userId) {
        System.out.println("内部加钱: " + System.currentTimeMillis());
        new Thread(new Runnable() {
            public void run() {
                moneyDao.incrementMoney(userId, 200);
                System.out.println("sub modify success! now: " + System.currentTimeMillis());
            }
        }).start();
    }
}

重点来了，主要是需要配置一个 TransactionProxyBeanFactory，我们知道BeanFactory就是我们自己来创建Bean的一种手段，相关的xml配置如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<!--编程式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<bean id="factoryBeanDemo2" class="com.git.hui.demo.mybatis.repository.transaction.FactoryBeanDemo2"/>

<!-- 配置业务层的代理 -->
<bean id="factoryBeanDemoProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <!-- 配置目标对象 -->
    <property name="target" ref="factoryBeanDemo2" />
    <!-- 注入事务管理器 -->
    <property name="transactionManager" ref="transactionManager"/>
    <!-- 注入事务的属性 -->
    <property name="transactionAttributes">
        <props>
            <!--
                prop的格式:
                    * PROPAGATION   :事务的传播行为
                    * ISOTATION     :事务的隔离级别
                    * readOnly      :只读
                    * -EXCEPTION    :发生哪些异常回滚事务
                    * +EXCEPTION    :发生哪些异常不回滚事务
             -->
             <!-- 这个key对应的就是目标类中的方法-->
            <prop key="transfor">PROPAGATION_REQUIRED</prop>
            <!-- <prop key="transfer">PROPAGATION_REQUIRED,readOnly</prop> -->
            <!-- <prop key="transfer">PROPAGATION_REQUIRED,+java.lang.ArithmeticException</prop> -->
        </props>
    </property>
</bean>

通过上面的配置，大致可以了解到这个通过TransactionProxyFactoryBean就是创建了一个FactoryBeanDemo2的代理类，这个代理类内部封装好事务相关的逻辑，可以看做是前面编程式的一种简单通用抽象

b. 测试

测试代码与前面基本相同，唯一的区别就是我们使用的应该是上面BeanFactory生成的Bean，而不是直接使用FactoryBeanDemo2

正常演示case:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath*:spring/service.xml", "classpath*:test-datasource2.xml"})
public class FactoryBeanDemo1Test {

    @Resource(name = "factoryBeanDemoProxy")
    private FactoryBeanDemo2 factoryBeanDemo2;

    @Autowired
    private MoneyDao moneyDao;


    @Test
    public void testTransfor() {

        System.out.println("---------before----------");
        System.out.println("id: 1 money = " + moneyDao.queryMoney(1).getMoney());
        System.out.println("id: 2 money = " + moneyDao.queryMoney(2).getMoney());


        factoryBeanDemo2.transfor(1, 2, 10, 0);

        System.out.println("---------after----------");
        System.out.println("id: 1 money = " + moneyDao.queryMoney(1).getMoney());
        System.out.println("id: 2 money = " + moneyDao.queryMoney(2).getMoney());
    }
}

输出

1
2
3
4
5
6
7
---------before----------
id: 1 money = 10000
id: 2 money = 50000
转账完成! now: 1526132058886
---------after----------
id: 1 money = 10010
id: 2 money = 49990

status为1，内部异常的情况下，我们希望钱也不会有问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Test
public void testTransforException() {

    System.out.println("---------before----------");
    System.out.println("id: 1 money = " + moneyDao.queryMoney(1).getMoney());
    System.out.println("id: 2 money = " + moneyDao.queryMoney(2).getMoney());


    try {
        factoryBeanDemo2.transfor(1, 2, 10, 1);
    } catch (Exception e) {
        System.out.println(e.getMessage());;
    }

    System.out.println("---------after----------");
    System.out.println("id: 1 money = " + moneyDao.queryMoney(1).getMoney());
    System.out.println("id: 2 money = " + moneyDao.queryMoney(2).getMoney());
}

输出为

1
2
3
4
5
6
7
---------before----------
id: 1 money = 10010
id: 2 money = 49990
转账异常!!!
---------after----------
id: 1 money = 10010
id: 2 money = 49990

status为2 时，分析结果与上面应该相同，输出如下

1
2
3
4
5
6
7
8
9
---------before----------
id: 1 money = 10010
id: 2 money = 49950
内部加钱: 1526133325376
sub modify success! now: 1526133325387
转账完成! now: 1526133328381
---------after----------
id: 1 money = 10220
id: 2 money = 49940

status为3时，输出

1
2
3
4
5
6
7
8
9
---------before----------
id: 1 money = 10220
id: 2 money = 49940
内部加钱: 1526133373466
转账完成! now: 1526133376476
sub modify success! now: 1526133376480
---------after----------
id: 1 money = 10230
id: 2 money = 50130

c. 小结

TransactionProxyFactoryBean 的思路就是利用代理模式来实现事务管理，生成一个代理类，拦截目标方法，将一组sql的操作封装到事务中进行；相比较于硬编码，无侵入，而且支持灵活的配置方式

缺点也显而易见，每个都要进行配置，比较繁琐

3. xml使用方式

Spring有两大特点，IoC和AOP，对于事务这种情况而言，我们可不可以使用AOP来做呢？

对于需要开启事务的方法，拦截掉，执行前开始事务，执行完毕之后提交事务，出现异常时回滚

这样一看，感觉还是蛮有希望的，而下面两种姿势正是这么玩的，因此需要加上aspect的依赖

1
2
3
4
5
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.7</version>
</dependency>

a. 实现

java类与第二种完全一致，变动的只有xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<!-- 首先添加命名空间 -->
xmlns:tx="http://www.springframework.org/schema/tx" 
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="...
  http://www.springframework.org/schema/tx
 http://www.springframework.org/schema/tx/spring-tx.xsd"



<!--对应的事务通知和切面配置-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!--
            propagation :事务传播行为
            isolation   :事务的隔离级别
            read-only   :只读
            rollback-for:发生哪些异常回滚
            no-rollback-for :发生哪些异常不回滚
            timeout     :过期信息
         -->
        <tx:method name="transfor" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>



<!-- 配置切面 -->
<aop:config>
    <!-- 配置切入点 -->
    <aop:pointcut expression="execution(* com.git.hui.demo.mybatis.repository.transaction.XmlDemo3.*(..))" id="pointcut1"/>
    <!-- 配置切面 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
</aop:config>

观察上面的配置，再想想第二种方式，思路都差不多了，但是这种方式明显更加通用，通过切面和切点，可以减少大量的配置

b. 测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath*:spring/service.xml", "classpath*:test-datasource3.xml"})
public class XmlBeanTest {
    @Autowired
    private XmlDemo3 xmlDemo;

    @Autowired
    private MoneyDao moneyDao;


    @Test
    public void testTransfor() {

        System.out.println("---------before----------");
        System.out.println("id: 1 money = " + moneyDao.queryMoney(1).getMoney());
        System.out.println("id: 2 money = " + moneyDao.queryMoney(2).getMoney());


        xmlDemo.transfor(1, 2, 10, 0);

        System.out.println("---------after----------");
        System.out.println("id: 1 money = " + moneyDao.queryMoney(1).getMoney());
        System.out.println("id: 2 money = " + moneyDao.queryMoney(2).getMoney());
    }
}

这个测试起来，和一般的写法就没啥两样了，比第二种的FactoryBean的注入方式简单点

正常输出

1
2
3
4
5
6
7
---------before----------
id: 1 money = 10000
id: 2 money = 50000
转账完成! now: 1526135301273
---------after----------
id: 1 money = 10010
id: 2 money = 49990

status=1 出现异常时，输出

1
2
3
4
5
6
7
---------before----------
id: 1 money = 10010
id: 2 money = 49990
转账异常!!!
---------after----------
id: 1 money = 10010
id: 2 money = 49990

status=2 转账过程中，又存钱的场景，输出，与前面预期一致

1
2
3
4
5
6
7
8
9
---------before----------
id: 1 money = 10010
id: 2 money = 49990
内部加钱: 1526135438403
sub modify success! now: 1526135438421
转账完成! now: 1526135441410
---------after----------
id: 1 money = 10220
id: 2 money = 49980

status=3 的输出，与前面预期一致

1
2
3
4
5
6
7
8
9
---------before----------
id: 1 money = 10220
id: 2 money = 49980
内部加钱: 1526135464341
转账完成! now: 1526135467349
sub modify success! now: 1526135467352
---------after----------
id: 1 money = 10230
id: 2 money = 50170

4. 注解方式

这个就是消灭xml，用注解来做的方式，就是将前面xml中的配置用 @Transactional注解替换

a. 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@Repository
public class AnnoDemo4 {

    @Autowired
    private MoneyDao moneyDao;


    /**
     * 转账
     *
     * @param inUserId
     * @param outUserId
     * @param payMoney
     * @param status    0 表示正常转账， 1 表示内部抛出一个异常， 2 表示新开一个线程，修改inUserId的钱 +200， 3 表示新开一个线程，修改outUserId的钱 + 200
     *
     *
     * Transactional注解中的的属性 propagation :事务的传播行为 isolation :事务的隔离级别 readOnly :只读
     * rollbackFor :发生哪些异常回滚 noRollbackFor :发生哪些异常不回滚
     * rollbackForClassName 根据异常类名回滚
     */
    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, readOnly = false)
    public void transfor(final int inUserId, final int outUserId, final int payMoney, final int status) {

        MoneyEntity entity = moneyDao.queryMoney(outUserId);
        if (entity.getMoney() > payMoney) { // 可以转账

            // 先减钱
            moneyDao.incrementMoney(outUserId, -payMoney);


            testCase(inUserId, outUserId, status);


            // 再加钱
            moneyDao.incrementMoney(inUserId, payMoney);
            System.out.println("转账完成! now: " + System.currentTimeMillis());
        }


    }


    private void testCase(final int inUserId, final int outUserId, final int status) {
        if (status == 1) {
            throw new IllegalArgumentException("转账异常!!!");
        } else if (status == 2) {
            addMoney(inUserId);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else if (status == 3) {
            addMoney(outUserId);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    private void addMoney(final int userId) {
        System.out.println("内部加钱: " + System.currentTimeMillis());
        new Thread(new Runnable() {
            public void run() {
                moneyDao.incrementMoney(userId, 200);
                System.out.println("sub modify success! now: " + System.currentTimeMillis());
            }
        }).start();
    }

}

因此需要在xml中配置，开启事务注解

1
2
3
4
5
6
7
8

<!--编程式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>


<tx:annotation-driven transaction-manager="transactionManager"/>

这样一看，就更加清晰了，实际项目中，xml和注解方式也是用得最多的场景了

b. 测试case

和第三种测试case完全相同, 输出结果也一样，直接省略

III. 小结

上面说了Spring中四种使用事务的姿势，其中硬编码方式可能是最好理解的，就相当于将我们写sql中，使用事务的方式直接翻译成对应的java代码了；而FactoryBean方式相当于特殊情况特殊对待，为每个事务来一个代理类来增强事务功能；后面的两个则原理差不多都是利用事务通知（AOP)来实现，定义切点及相关信息

编程式：

  • 注入 TransactionTemplate
  • 将利用事务的逻辑封装到 transactionTemplate#execute方法内

代理BeanFactory：

  • 利用 TransactionProxyFactoryBean 为事务相关类生成代理
  • 使用方通过FactoryBean获取代理类，作为使用的Bean

xml配置：

  • 利用 tx标签 + aop方式来实现
  • <tx:advice> 标签定义事务通知，内部可有较多的配置信息
  • <aop:config> 配置切点，切面

注解方式：

  • 在开启事务的方法or类上添加 @Transactional 注解即可
  • 开启事务注解 <tx:annotation-driven transaction-manager="transactionManager"/>

IV. 其他

1. 参考

文档

源码

2. 个人博客： 一灰灰Blog

基于hexo + github pages搭建的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

3. 声明

尽信书则不如，已上内容，纯属一家之言，因本人能力一般，见识有限，如发现bug或者有更好的建议，随时欢迎批评指正

4. 扫描关注

QrCode

开源 / Mybatis
11 分钟 读完 (大约 1712 个字)

Mybatis框架学习之使用篇二：标签语法

Mybatis框架学习之使用篇二：标签语法

常用标签的使用姿势小结及参数绑定的三种方式

  • select
  • update
  • delete
  • insert
  • choose, when, otherwise
  • if
  • bind
  • foreach
  • trim
  • set
  • where
阅读更多
开源 / Mybatis
7 分钟 读完 (大约 1080 个字)

Mybatis框架学习之使用篇一：基本环境

Mybatis框架学习之使用篇

主要介绍如何使用mybatis，来实现db的增删改查，通常mybatis一般是结合spring来使用，因此我们也不脱离这个大环境

主要内容将包括以下：

  • 环境配置相关
  • Dao文件与xml的映射（接口绑定有两种，xml和注解方式，这里以xml方式进行说明）
  • 增删改查的写法
  • 常用命令 choose, if, set, ….
  • #，$两种方式的区别
阅读更多
开源 / Hystrix
14 分钟 读完 (大约 2056 个字)

熔断Hystrix使用尝鲜

熔断Hystrix使用尝鲜

当服务有较多外部依赖时，如果其中某个服务的不可用，导致整个集群会受到影响（比如超时，导致大量的请求被阻塞，从而导致外部请求无法进来），这种情况下采用hystrix就很有用了

出于这个目的，了解了下hystrix框架，下面记录下，框架尝新的历程

I. 原理探究

通过官网和相关博文，可以简单的说一下这个工作机制，大致流程如下

首先是请求过来 -> 判断熔断器是否开 -> 服务调用 -> 异常则走fallback，失败计数+1 -> 结束

下面是主流程图

流程图

1
2
3
4
5
6
7
8
9
10
graph LR
    A(请求)-->B{熔断器是否已开}
    B --> | 熔断 | D[fallback逻辑]
    B --> | 未熔断 | E[线程池/Semphore]
    E --> F{线程池满/无可用信号量}
    F --> | yes | D
    F --> | no | G{创建线程执行/本线程运行}
    G --> | yes | I(结束)
    G --> | no | D
    D --> I(结束)

熔断机制主要提供了两种，一个是基于线程池的隔离方式来做；还有一个则是根据信号量的抢占来做

线程池方式 ： 支持异步，支持超时设置，支持限流

信号量方式 ： 本线程执行，无异步，无超时，支持限流，消耗更小

基本上有上面这个简单的概念之后，开始进入我们的使用测试流程

II. 使用尝鲜

1. 引入依赖

1
2
3
4
5
<dependency>
    <groupId>com.netflix.hystrix</groupId>
    <artifactId>hystrix-core</artifactId>
    <version>1.5.12</version>
</dependency>

2. 简单使用

从官方文档来看，支持两种Command方式，一个是基于观察者模式的ObserverCommand, 一个是基本的Command，先用简单的看以下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
public class HystrixConfigTest extends HystrixCommand<String> {

    private final String name;

    public HystrixConfigTest(String name, boolean ans) {
//        注意的是同一个任务，
        super(Setter.withGroupKey(
//                CommandGroup是每个命令最少配置的必选参数，在不指定ThreadPoolKey的情况下，字面值用于对不同依赖的线程池/信号区分
                HystrixCommandGroupKey.Factory.asKey("CircuitBreakerTestGroup"))
//                每个CommandKey代表一个依赖抽象,相同的依赖要使用相同的CommandKey名称。依赖隔离的根本就是对相同CommandKey的依赖做隔离.
                        .andCommandKey(HystrixCommandKey.Factory.asKey("CircuitBreakerTestKey_" + ans))
//                当对同一业务依赖做隔离时使用CommandGroup做区分,但是对同一依赖的不同远程调用如(一个是redis 一个是http),可以使用HystrixThreadPoolKey做隔离区分
                        .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("CircuitBreakerTest_" + ans))
                        .andThreadPoolPropertiesDefaults(    // 配置线程池
                                HystrixThreadPoolProperties.Setter()
                                        .withCoreSize(12)    // 配置线程池里的线程数，设置足够多线程，以防未熔断却打满threadpool
                        )
                        .andCommandPropertiesDefaults(    // 配置熔断器
                                HystrixCommandProperties.Setter()
                                        .withCircuitBreakerEnabled(true)
                                        .withCircuitBreakerRequestVolumeThreshold(3)
                                        .withCircuitBreakerErrorThresholdPercentage(80)
//                		.withCircuitBreakerForceOpen(true)	// 置为true时，所有请求都将被拒绝，直接到fallback
//                		.withCircuitBreakerForceClosed(true)	// 置为true时，将忽略错误
//                                        .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.SEMAPHORE)    // 信号量隔离
                                        .withExecutionIsolationSemaphoreMaxConcurrentRequests(20)
                                        .withExecutionTimeoutEnabled(true)
                                        .withExecutionTimeoutInMilliseconds(200)
                                .withCircuitBreakerSleepWindowInMilliseconds(1000) //熔断器打开到关闭的时间窗长度
//                		.withExecutionTimeoutInMilliseconds(5000)
                        )
        );
        this.name = name;
    }

    @Override
    protected String run() throws Exception {
        System.out.println("running run():" + name + " thread: " + Thread.currentThread().getName());
        int num = Integer.valueOf(name);
        if (num % 2 == 0 && num < 10) {    // 直接返回
            return name;
        } else if (num < 40) {
            Thread.sleep(300);
            return "sleep+"+ name;
        } else {    // 无限循环模拟超时
            return name;
        }
    }
//
//    @Override
//    protected String getFallback() {
//        Throwable t = this.getExecutionException();
//        if(t instanceof HystrixRuntimeException) {
//            System.out.println(Thread.currentThread() + " --> " + ((HystrixRuntimeException) t).getFailureType());
//        } else if (t instanceof HystrixTimeoutException) {
//            System.out.println(t.getCause());
//        } else {
//            t.printStackTrace();
//        }
//        System.out.println(Thread.currentThread() + " --> ----------over------------");
//        return "CircuitBreaker fallback: " + name;
//    }

    public static class UnitTest {

        @Test
        public void testSynchronous() throws IOException, InterruptedException {
            for (int i = 0; i < 50; i++) {
                if (i == 41) {
                    Thread.sleep(2000);
                }
                try {
                    System.out.println("===========" + new HystrixConfigTest(String.valueOf(i), i % 2 == 0).execute());
                } catch (HystrixRuntimeException e) {
                    System.out.println(i + " : " + e.getFailureType() + " >>>> " + e.getCause() + " <<<<<");
                } catch (Exception e) {
                    System.out.println("run()抛出HystrixBadRequestException时，被捕获到这里" + e.getCause());
                }
            }

            System.out.println("------开始打印现有线程---------");
            Map<Thread, StackTraceElement[]> map = Thread.getAllStackTraces();
            for (Thread thread : map.keySet()) {
                System.out.println("--->name-->" + thread.getName());
            }
            System.out.println("thread num: " + map.size());

            System.in.read();
        }
    }
}

使用起来还是比较简单的，一般步骤如下：

  • 继承 HsytrixCommand 类
  • 重载构造方法，内部需要指定各种配置
  • 实现run方法，这个里面主要执行熔断监控的方法

写上面的代码比较简单，但是有几个地方不太好处理

  1. 配置项的具体含义，又是怎么生效的？
  2. 某些异常不进入熔断逻辑怎么办？
  3. 监控数据如何获取？
  4. 如何模拟各种不同的case（超时？服务异常？熔断已开启？线程池满？无可用信号量？半熔断的重试？）

3. 实测理解

根据上面那一段代码的删删改改，貌似理解了以下几个点，不知道对误

a. 配置相关

  • groupKey 用于区分线程池和信号量，即一个group对应一个
  • commandKey 很重要，这个是用于区分业务
    • 简单来讲，group类似提供服务的app，command则对应app提供的service，一个app可以有多个service，这里就是将一个app的所有请求都放在一个线程池（or共享一个信号量）
  • 开启熔断机制，指定触发熔断的最小请求数（10s内），指定打开熔断的条件（失败率）
  • 设置熔断策略（线程池or信号量）
  • 设置重试时间（默认熔断开启后5s，放几个请求进去，看服务是否恢复）
  • 设置线程池大小，设置信号量大小，设置队列大小
  • 设置超时时间，设置允许超时设置

b. 使用相关

run方法是核心执行服务调用，如果需要某些服务不统计到熔断的失败率（比如因为调用姿势不对导致服务内部的异常抛上来了，但是服务本身是正常的），这个时候，就需要包装下调用逻辑，将不需要的异常包装到 HystrixBadRequestException 类里

如

1
2
3
4
5
6
7
8
9
10
11
12
13
@Override
protected String run() {
    try {
        return func.apply(route, parameterDescs);
    } catch (Exception e) {
        if (exceptionExcept(e)) {
            // 如果是不关注的异常case， 不进入熔断逻辑
            throw new HystrixBadRequestException("unexpected exception!", e);
        } else {
            throw e;
        }
    }
}

c. 如何获取失败的原因

当发生失败时，hystrix会把原生的异常包装到 HystrixRuntimeException 这个类里，所以我们可以在调用的地方如下处理

1
2
3
4
5
6
7
try {
    System.out.println("===========" + new HystrixConfigTest(String.valueOf(i), i % 2 == 0).execute());
} catch (HystrixRuntimeException e) {
    System.out.println(i + " : " + e.getFailureType() + " >>>> " + e.getCause() + " <<<<<");
} catch (Exception e) {
    System.out.println("run()抛出HystrixBadRequestException时，被捕获到这里" + e.getCause());
}

当定义了fallback逻辑时，异常则不会抛到具体的调用方，所以在 fallback 方法内，则有必要获取对应的异常信息

1
2
// 获取异常信息
Throwable t = this.getExecutionException();

然后下一步就是需要获取对应的异常原因了，通过FailureType来表明失败的根源

1
((HystrixRuntimeException) t).getFailureType()

d.如何获取统计信息

hystrix自己提供了一套监控插件，基本上公司内都会有自己的监控统计信息，因此需要对这个数据进行和自定义，目前还没看到可以如何优雅的处理这些统计信息

4. 小结

主要是看了下这个东西可以怎么玩，整个用下来的感觉就是，设计的比较有意思，但是配置参数太多，很多都没有完全摸透

其次就是一些特殊的case（如监控，报警，特殊情况过滤）需要处理时，用起来并不是很顺手，主要问题还是没有理解清楚这个框架的内部工作机制的问题

III. 其他

个人博客： Z+|blog

基于hexo + github pages搭建的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

声明

尽信书则不如，已上内容，纯属一家之言，因本人能力一般，见识有限，如发现bug或者有更好的建议，随时欢迎批评指正

扫描关注

QrCode

开源 / Spring / 使用小结
2 分钟 读完 (大约 252 个字)

SpringMVC统一异常处理

统一异常拦截处理方式

项目中不可避免会出现一些异常情况，而一个web项目，若不拦截异常，糟糕的情况下可能直接将堆栈抛给前端，从而导致各种鬼畜的问题

阅读更多
开源 / Spring / 使用小结
7 分钟 读完 (大约 1101 个字)

SpringMVC支持跨域的几种姿势

SpringMVC支持跨域的几种姿势

跨域好像是一个前端的问题，通常是a域名下向b域名的服务发起请求，然后处于浏览器的安全原则，被拦截了，而这种场景，在实际的项目中并不少见，那么作为后端可以怎么去支持跨域的case呢？

后端需要支持跨域，一个是支持jsonp请求；还有一个就是设置responseHeader中crossOrigin等相关参数

阅读更多
开源 / Spring / 使用小结
10 分钟 读完 (大约 1558 个字)

SpringMVC返回图片的几种方式

SpringMVC返回图片的几种方式

后端提供服务，通常返回的json串，但是某些场景下可能需要直接返回二进制流，如一个图片编辑接口，希望直接将图片流返回给前端；如果要求返回base64，此时可以怎么处理？

阅读更多
开源 / Redis
17 分钟 读完 (大约 2481 个字)

Redis实现分布式锁相关注意事项

Redis实现分布式锁相关注意事项

查看了不少关于redis实现分布式锁的文章，无疑要设计一个靠谱的分布式并不太容易，总会出现各种鬼畜的问题；现在就来小述一下，在设计一个分布式锁的过程中，会遇到一些什么问题

阅读更多
开源 / Spring / 使用小结
17 分钟 读完 (大约 2570 个字)

SpringMVC之请求参数的获取方式

SpringMVC之请求参数的获取方式

常见的一个web服务，如何获取请求参数？

一般最常见的请求为GET和POST，get请求的参数在url上可以获取，post请求参数除了url上还有可能在表单中，文件上传时，获取方式又和一般的参数获取不一样

本篇则主要集中在不同请求方式下，获取参数的使用姿势

首先需要搭建一个后端的请求，为了快速演示

利用spring-boot创建了一个机器简单的工程，依赖版本 1.5.4.RELEASE

阅读更多
关注我
Google Play    Android

链接

最新文章

标签云

AES Android Arthas AutoCloseable BeanUtil BloomFilter BufferedImage BugFix Bugfix CURL Chrome DNS Docker Dubbo ElasticSearch Email FastJson Git GitHub Grafana Groovy Gson Guava HashMap IDEA IO ImageMagic InfluxDB InputStream Iterator JDK JNDI JVM Jackson Java JavaAgent JavaScript JavaWeb Jquery Json LRU Linux List MD5 Map Maven Mongo MongoDB MongoDb MySql Mybatis Mysql Nginx Node OGNL Prometheus ProtoStuff Python QlExpress QuickAlarm QuickMedia RMI RabbitMQ ReactJS Redis SSL Shell Socket Solr Spring SpringBoot Vue WebSocket WebView Win10 Yaml ZooKeeper css curl dns ffmpeg git gitalk google grep hexo hostname jdk logger markdown named ncat python ssh ssl time tmux zsh 专业词汇 乱码 二维码 代理 内购 分库分表 反射 吐槽 子系统 工具 并发 序列化 手记 技术方案 指南 教程 方案设计 时区 时间窗口 爬虫 编程技巧 证书 问题记录 随笔

标签

AES 1
Android 4
Arthas 1
AutoCloseable 1
BeanUtil 2
BloomFilter 1
BufferedImage 2
BugFix 2
Bugfix 2
CURL 2
Chrome 2
DNS 1
Docker 5
Dubbo 1
ElasticSearch 7
Email 1
FastJson 1
Git 3
GitHub 1
Grafana 3
Groovy 1
Gson 5
Guava 5
HashMap 1
IDEA 4
IO 2
ImageMagic 2
InfluxDB 17
InputStream 1
Iterator 1
JDK 36
JNDI 3
JVM 3
Jackson 1
Java 75
JavaAgent 2
JavaScript 2
JavaWeb 2
Jquery 1
Json 1
LRU 1
Linux 11
List 1
MD5 1
Map 1
Maven 4
Mongo 2
MongoDB 4
MongoDb 10
MySql 3
Mybatis 2
Mysql 21
Nginx 7
Node 1
OGNL 4
Prometheus 1
ProtoStuff 2
Python 142
QlExpress 4
QuickAlarm 1
QuickMedia 3
RMI 3
RabbitMQ 9
ReactJS 1
Redis 9
SSL 1
Shell 21
Socket 2
Solr 1
Spring 26
SpringBoot 2
Vue 1
WebSocket 1
WebView 2
Win10 2
Yaml 1
ZooKeeper 1
css 3
curl 1
dns 1
ffmpeg 1
git 2
gitalk 1
google 1
grep 1
hexo 1
hostname 1
jdk 1
logger 1
markdown 1
named 1
ncat 1
python 2
ssh 1
ssl 1
time 1
tmux 2
zsh 1
专业词汇 1
乱码 1
二维码 3
代理 1
内购 1
分库分表 1
反射 3
吐槽 1
子系统 1
工具 5
并发 3
序列化 1
手记 6
技术方案 22
指南 6
教程 21
方案设计 1
时区 1
时间窗口 3
爬虫 5
编程技巧 15
证书 1
问题记录 1
随笔 1

分类

归档

分类

归档

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×