原创

Spring系列第54篇:集成junit

通常我们写完代码之后,为了确保代码的正确性,都需要自己测试一遍,看一下代码的运行结果和我们期望的结果是不是一样的,也就是我们常说的单元测试,java中最常用的单元测试框架是junit,本文主要介绍3个内容:

1、玩转junit

2、spring集成junit

3、开发工具中使用junit

1、背景

我们写了一个工具类,有2个方法

package com.javacode2018.junit.demo1;

public class MathUtils {
    /**
     * 获取最大的数字
     *
     * @param args
     * @return
     */
    public static int max(int... args) {
        int result = Integer.MIN_VALUE;
        for (int arg : args) {
            result = result > arg ? result : arg;
        }
        return result;
    }

    /**
     * 获取最小的数字
     *
     * @param args
     * @return
     */
    public static int min(int... args) {
        int result = Integer.MAX_VALUE;
        for (int arg : args) {
            result = result < arg ? result : arg;
        }
        return result;
    }

}

然后我们想测试这两个方法,下面我们来写测试代码,如下,测试一下max方法和min方法的结果和我们期望的结果是否一致,不一致的时候,输出一段文字

package com.javacode2018.junit.demo1;

public class MathUtilsTest1 {
    public static void main(String[] args) {
        testMax();
        testMin();
    }

    public static void testMax() {
        int result = MathUtils.max(1, 2, 3);
        if (result != 3) {
            System.out.println(String.format("max 方法有问题,期望结果是3,实际结果是%d", result));
        }
    }

    public static void testMin() {
        int result = MathUtils.min(1, 2, 3);
        if (result != 1) {
            System.out.println(String.format("min 方法有问题,期望结果是3,实际结果是%d", result));
        }
    }
}

上面我们要测试的方法就2个,若需测试的方法很多的时候,咱们需要写大量的这种测试代码,工作量还是蛮大的,而junit做的事情和上面差不多,都是用来判断被测试的方法和期望的结果是否一致,不一致的时候给出提示,不过junit用起来更容易一些,还有各种开发用到的ide(eclipse、idea)结合的更好一些,用起来特别的顺手。

2、junit用法详解

2.1、使用步骤

1)、添加junit maven配置,这里我们就用4.13,你们也可以用最新的

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
</dependency>

2)、写测试用例,在写好的测试方法上面添加@Test注解,比如我们需要对上面案例中的max方法进行测试,通常我们会新建一个测试类,类名为被测试的类加上Test后缀,即:MathUtilsTest,然后在这个类我们需要写max方法的测试方法,如下,需要我们在max方法上面加上@Test注解

package com.javacode2018.junit.demo1;

import org.junit.Assert;
import org.junit.Test;

public class MathUtilsTest {
    @Test
    public void max() throws Exception {
        int result = MathUtils.max(1, 2, 3);
        //判断测试结果和我们期望的结果是否一致
        Assert.assertEquals(result, 3);
    }
}

3、运行测试用例,现在测试代码都写好了,下面我们写个类来启动测试用例,这里需要使用JUnitCore.runClasses方法来运行测试用例,如下:

package com.javacode2018.junit.demo1;

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class Demo1TestRunner {
    public static void main(String[] args) {
        //使用JUnitCore.runClasses方法传入测试用例的类,然后获取测试用例的运行结果
        Result result = JUnitCore.runClasses(MathUtilsTest.class);
        //获取失败的用例
        for (Failure failure : result.getFailures()) {
            System.out.println(failure);
        }
        //获取所有测试用例是否执行成功
        System.out.println(result.wasSuccessful());
    }
}

2.2、同时运行多个测试用例

可以一个测试类中写多个测试方法,每个方法上加上@Test注解就可以了,然后通过JUnitCore来执行就可以,下面代码中我们写2个方法对MathUtils中的max和min方法都进行测试,我们故意将执行结果和期望结果搞成不一致的,运行下面代码,然后看看运行结果。

package com.javacode2018.junit.demo2;

import com.javacode2018.junit.demo1.MathUtils;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.manipulation.Ordering;
import org.junit.runner.notification.Failure;

public class MathUtilsTest2 {
    @Test
    public void max() throws Exception {
        int result = MathUtils.max(1, 2, 3);
        //判断测试结果和我们期望的结果是否一致
        Assert.assertEquals(result, 1);
    }

    @Test
    public void min() throws Exception {
        int result = MathUtils.min(1, 2, 3);
        //判断测试结果和我们期望的结果是否一致
        Assert.assertEquals(result, 3);
    }

    public static void main(String[] args) {
        Result result = JUnitCore.runClasses(MathUtilsTest2.class);

        System.out.println("失败用例个数:" + result.getFailures().size());
        for (Failure failure : result.getFailures()) {
            System.out.println(failure);
        }
        System.out.println("运行测试用例个数:" + result.getRunCount());
        System.out.println("运行测试用例总耗时(ms):" + result.getRunTime());
        System.out.println("测试用例是否都成功了:" + result.wasSuccessful());
    }
}

运行输出如下,运行了2个用例,失败了2个,测试的详细信息都被输出了

失败用例个数:2
max(com.javacode2018.junit.demo2.MathUtilsTest2): expected:<3> but was:<1>
min(com.javacode2018.junit.demo2.MathUtilsTest2): expected:<1> but was:<3>
运行测试用例个数:2
运行测试用例总耗时(ms):11
测试用例是否都成功了:false

2.3、使用断言

什么是断言?

断言是用来判断程序的运行结果和我们期望的结果是不是一致的,如果不一致,会抛出异常,断言中有3个信息比较关键

1、被测试的数据

2、期望的数据

3、抛出异常

断言提供的方法将被测试的数据和期望的数据进行对比,如果不一样的时候,将抛出异常,程序可以捕获这个异常,这样就可以知道测试失败了。

junit中的org.junit.Assert类中提供了大量静态方法,用来判断被测试的数据和期望的数据是否一致,不一致,将抛出异常,这里随便列几个大家看一下吧

//判断condition如果不是true,将抛出异常,异常的提示信息是message
public static void assertTrue(String message, boolean condition) 

//判断expected和actual是否相等,如果不相等,将抛出异常
public static void assertEquals(Object expected, Object actual)

用法,如:

int result = MathUtils.max(1, 2, 3);
//判断测试结果和我们期望的结果是否一致
Assert.assertEquals(result, 1);

2.4、测试套件:批量运行测试用例

到目前为止,我们还只能一次运行一个测试类,如下

JUnitCore.runClasses(MathUtilsTest2.class)

但是在实际项目中,我们可能会有很多测试类,需要批量运行。

比如我们有下面2个测试类

MathUtilsTest3001.java

package com.javacode2018.junit.demo3;

import com.javacode2018.junit.demo1.MathUtils;
import org.junit.Assert;
import org.junit.Test;

public class MathUtilsTest3001 {
    @Test
    public void max() throws Exception {
        int result = MathUtils.max(1, 2, 3);
        //判断测试结果和我们期望的结果是否一致
        Assert.assertEquals(result, 3);
    }

    @Test
    public void min() throws Exception {
        int result = MathUtils.min(1, 2, 3);
        //判断测试结果和我们期望的结果是否一致
        Assert.assertEquals(result, 1);
    }
}

MathUtilsTest3002.java

package com.javacode2018.junit.demo3;

import com.javacode2018.junit.demo1.MathUtils;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class MathUtilsTest3002 {
    @Test
    public void max() throws Exception {
        int result = MathUtils.max(100, 99, 200);
        //判断测试结果和我们期望的结果是否一致
        Assert.assertEquals(result, 200);
    }

    @Test
    public void min() throws Exception {
        int result = MathUtils.min(1, -1, 10);
        //判断测试结果和我们期望的结果是否一致
        Assert.assertEquals(result, -1);
    }
}

现在我们希望同时运行上面2个测试类,我们可以这么做,创建一个AllTest.java类,注意这个类上有2个注解比较特殊,都是junit提供的,@RunWith表示这是一个测试套件类,需要批量运行测试类,具体要运行哪些测试类呢,通过@Suite.SuiteClasses来指定

package com.javacode2018.junit.demo3;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)
@Suite.SuiteClasses({MathUtilsTest3001.class, MathUtilsTest3002.class})
public class AllTest {
}

下面来个启动类,将AllTest传递给JUnitCore.runClasses

package com.javacode2018.junit.demo3;

import com.javacode2018.junit.demo1.MathUtilsTest;
import com.javacode2018.junit.demo2.MathUtilsTest2;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class Demo3TestRunner {
    public static void main(String[] args) {
        //@1:传入AllTest
        Result result = JUnitCore.runClasses(AllTest.class);

        System.out.println("失败用例个数:" + result.getFailures().size());
        for (Failure failure : result.getFailures()) {
            System.out.println(failure);
        }
        System.out.println("运行测试用例个数:" + result.getRunCount());
        System.out.println("运行测试用例总耗时(ms):" + result.getRunTime());
        System.out.println("测试用例是否都成功了:" + result.wasSuccessful());
    }
}

运行输出

失败用例个数:0
运行测试用例个数:4
运行测试用例总耗时(ms):12
测试用例是否都成功了:true

测试套件中不仅可以包含基本的测试类,而且可以包含其它的测试套件,这样可以很方便的分层管理不同模块的单元测试代码,比如下面代码,Module2Test和Module2Test都是测试套件

@RunWith(Suite.class)
@Suite.SuiteClasses({Test1.class, Test2.class})
public class Module2Test {
}

@RunWith(Suite.class)
@Suite.SuiteClasses({Test1.class, Test2.class})
public class Module2Test {
}

@RunWith(Suite.class)
@Suite.SuiteClasses({Module2Test.class, Module2Test.class, Test3.java})
public class AllTest {
}

//运行AllTest
JUnitCore.runClasses(AllTest.class);

2.5、Junit常用注解

1)@Test注解

@Test:将一个普通方法修饰成一个测试方法

@Test(excepted=xx.class):xx.class 表示异常类,表示测试的方法抛出此异常时,认为是正常的测试通过的

@Test(timeout = 毫秒数):测试方法执行时间是否符合预期

2)@BeforeClass

会在所有的方法执行前被执行,static 方法 (全局只会执行一次,而且是第一个运行)

3)@AfterClass

会在所有的方法执行之后进行执行,static 方法 (全局只会执行一次,而且是最后一个运行)

4)@Before

会在每一个测试方法被运行前执行一次

5)@After

会在每一个测试方法运行后被执行一次

6)@Ignore

所修饰的测试方法会被测试运行器忽略

7)@RunWith

可以更改测试运行器 org.junit.runner.Runner

下面的案例,基本上用到了上面所有的注解,大家结合输出理解一下。

package com.javacode2018.junit.demo4;

import com.javacode2018.junit.demo1.MathUtils;
import org.junit.*;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

import java.util.concurrent.TimeUnit;

public class MathUtilsTest4 {

    @BeforeClass
    public static void bc() {
        System.out.println("@BeforeClass");
        System.out.println("-----------------");
    }

    @AfterClass
    public static void ac() {
        System.out.println("@AfterClass");
    }

    @Before
    public void bf() {
        System.out.println("@Before:" + this);
    }

    @After
    public void af() {
        System.out.println("@After:" + this);
        System.out.println("##################");
    }

    @Test
    public void max() throws Throwable {
        System.out.println("max():" + this);
        int result = MathUtils.max(1, 2, 3);
        //判断测试结果和我们期望的结果是否一致
        Assert.assertEquals(result, 3);
    }

    @Test
    public void min() throws Exception {
        System.out.println("min():" + this);
        int result = MathUtils.min(1, 2, 3);
        //判断测试结果和我们期望的结果是否一致
        Assert.assertEquals(result, 1);
    }

    //方法运行时间超过了timeout,表示测试用例运行失败
    @Test(timeout = 1000)
    public void timeOutTest() throws InterruptedException {
        System.out.println("timeOutTest():" + this);
        TimeUnit.SECONDS.sleep(2000);
    }

    //方法若未抛出expected指定的异常,表示测试用例运行失败
    @Test(expected = NullPointerException.class)
    public void expectedTest() {
        System.out.println("expectedTest():" + this);
        new RuntimeException("异常不匹配");
    }

    @Test
    @Ignore
    public void ignoredMethod() {
        System.out.println("我是被忽略的方法");
    }

    public static void main(String[] args) {
        Result result = JUnitCore.runClasses(MathUtilsTest4.class);
        System.out.println("-----------------");
        System.out.println("运行测试用例个数:" + result.getRunCount());
        System.out.println("失败用例个数:" + result.getFailures().size());
        for (Failure failure : result.getFailures()) {
            System.out.println(failure);
        }
        System.out.println("运行测试用例总耗时(ms):" + result.getRunTime());
        System.out.println("测试用例是否都成功了:" + result.wasSuccessful());

    }
}

运行结果如下

@BeforeClass
-----------------
@Before:com.javacode2018.junit.demo4.MathUtilsTest4@78e03bb5
timeOutTest():com.javacode2018.junit.demo4.MathUtilsTest4@78e03bb5
@After:com.javacode2018.junit.demo4.MathUtilsTest4@78e03bb5
##################
@Before:com.javacode2018.junit.demo4.MathUtilsTest4@48533e64
max():com.javacode2018.junit.demo4.MathUtilsTest4@48533e64
@After:com.javacode2018.junit.demo4.MathUtilsTest4@48533e64
##################
@Before:com.javacode2018.junit.demo4.MathUtilsTest4@7e0b37bc
min():com.javacode2018.junit.demo4.MathUtilsTest4@7e0b37bc
@After:com.javacode2018.junit.demo4.MathUtilsTest4@7e0b37bc
##################
@Before:com.javacode2018.junit.demo4.MathUtilsTest4@1a93a7ca
expectedTest():com.javacode2018.junit.demo4.MathUtilsTest4@1a93a7ca
@After:com.javacode2018.junit.demo4.MathUtilsTest4@1a93a7ca
##################
@AfterClass
-----------------
运行测试用例个数:4
失败用例个数:3
timeOutTest(com.javacode2018.junit.demo4.MathUtilsTest4): test timed out after 1000 milliseconds
max(com.javacode2018.junit.demo4.MathUtilsTest4): hah 
expectedTest(com.javacode2018.junit.demo4.MathUtilsTest4): Expected exception: java.lang.NullPointerException
运行测试用例总耗时(ms):1018
测试用例是否都成功了:false

从输出中可以看出

  • @BeforeClass和@AfterClass标注的方法只会运行一次
  • 每个@Test标注的方法运行之前会先运行@Before标注的方法,然后运行@Test标注的这个方法,之后再运行@After
  • 从this的输出看出,每个@Test运行的时候,当前类的实例都会重新创建一个新的
  • 不论@Test标注的方法是否异常,@AfterClass、@After标注的方法都会执行,且异常会被淹没,输出中看不到异常信息

2.6、参数化测试

Junit 4 引入了一个新的功能参数化测试

参数化测试允许开发人员使用不同的值反复运行同一个测试,你将遵循 5 个步骤来创建参数化测试

  • 用 @RunWith(Parameterized.class) 来注释 test 类。
  • 创建一个由 @Parameters 注释的公共的静态方法,它返回一个对象的集合(数组)来作为测试数据集合。
  • 创建一个公共的构造函数,它接受和一行测试数据相等同的东西。
  • 为每一列测试数据创建一个实例变量。
  • 用实例变量作为测试数据的来源来创建你的测试用例。

可能大家看了上面的理解,还是比较迷糊。

比如我们com.javacode2018.junit.demo1.MathUtils#max测试下面几组数组

1,2,3
100,99,80
30,-1,100

我们可以这么写

package com.javacode2018.junit.demo5;

import com.javacode2018.junit.demo1.MathUtils;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.RunWith;
import org.junit.runner.notification.Failure;
import org.junit.runners.Parameterized;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@RunWith(Parameterized.class)
public class MathUtilsTest5 {

    public static class TestData {
        int[] testData;//测试数据
        int expectedValue;//预期的结果

        public TestData(int[] testData, int expectedValue) {
            this.testData = testData;
            this.expectedValue = expectedValue;
        }

        @Override
        public String toString() {
            return "TestData{" +
                    "testData=" + Arrays.toString(testData) +
                    ", expectedValue=" + expectedValue +
                    '}';
        }
    }

    private TestData testData;

    @Parameterized.Parameters
    public static List<TestData> initTestData() {
        System.out.println("initTestData()");
        //key:期望的结果,value:max方法需要测试的数据
        List<TestData> result = new ArrayList<>();
        result.add(new TestData(new int[]{1, 2, 3}, 3));
        result.add(new TestData(new int[]{100, 99, 80}, 100));
        result.add(new TestData(new int[]{30, -1, 100}, 100));
        return result;
    }

    public MathUtilsTest5(TestData testData) {
        System.out.println("MathUtilsTest5构造器:" + testData);
        this.testData = testData;
    }

    @Test
    public void maxTest() throws Throwable {
        System.out.println(this.hashCode() + ",maxTest():" + this.testData);
        int result = MathUtils.max(this.testData.testData);
        //判断测试结果和我们期望的结果是否一致
        Assert.assertEquals(this.testData.expectedValue, result);
        System.out.println("###################");
    }

    public static void main(String[] args) {
        Result result = JUnitCore.runClasses(MathUtilsTest5.class);
        System.out.println("-----------------");
        System.out.println("运行测试用例个数:" + result.getRunCount());
        System.out.println("失败用例个数:" + result.getFailures().size());
        for (Failure failure : result.getFailures()) {
            System.out.println(failure);
        }
        System.out.println("运行测试用例总耗时(ms):" + result.getRunTime());
        System.out.println("测试用例是否都成功了:" + result.wasSuccessful());

    }
}

为了方便大家理解代码的运行过程,代码中添加了很多日志输出,运行结果如下,结合代码和输出,理解很容易

initTestData()
MathUtilsTest5构造器:TestData{testData=[1, 2, 3], expectedValue=3}
721748895,maxTest():TestData{testData=[1, 2, 3], expectedValue=3}
###################
MathUtilsTest5构造器:TestData{testData=[100, 99, 80], expectedValue=100}
463345942,maxTest():TestData{testData=[100, 99, 80], expectedValue=100}
###################
MathUtilsTest5构造器:TestData{testData=[30, -1, 100], expectedValue=100}
195600860,maxTest():TestData{testData=[30, -1, 100], expectedValue=100}
###################
-----------------
运行测试用例个数:3
失败用例个数:0
运行测试用例总耗时(ms):12
测试用例是否都成功了:true

3、Spring集成junit

spring集成junit比较简单,下面我们来个案例感受一下。

3.1、加入maven配置

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
</dependency>

3.2、来个spring的入口配置类

package com.javacode2018.springjunit;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MainConfig {
    @Bean
    public String name() {
        return "路人甲java";
    }

    @Bean
    public int age() {
        return 30;
    }
}

3.3、来个junit测试类集成spring

下面我们来个测试类,对上面的MainConfig中注册的2个bean进行测试

package com.javacode2018.springjunit;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class) //@1
@ContextConfiguration(classes = {MainConfig.class}) //@2
public class MainConfigTest {

    @Autowired
    private String name;

    @Autowired
    private int age;

    @Test
    public void nameTest() {
        System.out.println(this.name);
        Assert.assertEquals("路人甲java", this.name);
    }

    @Test
    public void ageTest() {
        System.out.println(this.age);
        Assert.assertEquals(30, this.age);
    }
}

注意上面的@1和@2的代码了,这就是spring集成junit的关键代码,@Runwith的值是org.springframework.test.context.junit4.SpringRunner,@ContextConfiguration注解通过classes属性指定spring启动类,如果是xml的方式,可以使用另外一个属性value或者locations来指定入口xml的位置。

上面代码中name和age属性上面都有@Autowired注解,这2个属性会被自动从spring容器中注入进来。

3.4、来个测试启动类

package com.javacode2018.springjunit;

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {

    public static void main(String[] args) {
        Result result = JUnitCore.runClasses(MainConfigTest.class);
        System.out.println("-----------------");
        System.out.println("运行测试用例个数:" + result.getRunCount());
        System.out.println("失败用例个数:" + result.getFailures().size());
        for (Failure failure : result.getFailures()) {
            System.out.println(failure);
        }
        System.out.println("运行测试用例总耗时(ms):" + result.getRunTime());
        System.out.println("测试用例是否都成功了:" + result.wasSuccessful());

    }

}

运行输出

30
路人甲java
-----------------
运行测试用例个数:2
失败用例个数:0
运行测试用例总耗时(ms):422
测试用例是否都成功了:true

4、开发工具中使用junit

上面介绍的所有案例,都是通过main方法中用JUnitCore.runClasses来运行测试用例的,实际上有更简单的方式。

java的常用开发工具有eclipse和idea,这两个工具都将junit集成好了,通过开发工具继承的功能,运行测试用例更方便,不需要我们写JUnitCore.runClasses代码了。

我们来演示一下,如下图

file

点击1处的蓝色箭头,即可运行当前测试类中的所有用例,即2个测试方法,运行效果如下,左边显示了运行的测试用例列表,右边的显示了输出信息。

file

图中的2和3也可以点击,只会运行选中的那个测试方法,比如点击2,只会运行nameTest()这个用例,效果如下

file

5、总结

1、本文详细介绍了junit的用法,常用的注解有@Test、@BeforeClass、@AfterClass、@Before、@After、@Ignore、@RunWith,这些都要掌握

2、spring中集成junit,主要的配置就是在测试类上面需要加上下面代码

@RunWith(SpringRunner.class) //@1
@ContextConfiguration(classes = {MainConfig.class}) //@2

3、开发工具中使用junit更容易

6、案例源码

git地址:
https://gitee.com/javacode2018/spring-series

本文案例对应源码:
    spring-series\lesson-008-junit
    spring-series\lesson-008-springjunit

大家star一下,所有系列代码都会在这个里面,还有所有原创文章的连接也在里面,方便查阅!!!

7、Spring系列

  1. Spring系列第1篇:为何要学spring?
  2. Spring系列第2篇:控制反转(IoC)与依赖注入(DI)
  3. Spring系列第3篇:Spring容器基本使用及原理
  4. Spring系列第4篇:xml中bean定义详解(-)
  5. Spring系列第5篇:创建bean实例这些方式你们都知道?
  6. Spring系列第6篇:玩转bean scope,避免跳坑里!
  7. Spring系列第7篇:依赖注入之手动注入
  8. Spring系列第8篇:自动注入(autowire)详解,高手在于坚持
  9. Spring系列第9篇:depend-on到底是干什么的?
  10. Spring系列第10篇:primary可以解决什么问题?
  11. Spring系列第11篇:bean中的autowire-candidate又是干什么的?
  12. Spring系列第12篇:lazy-init:bean延迟初始化
  13. Spring系列第13篇:使用继承简化bean配置(abstract & parent)
  14. Spring系列第14篇:lookup-method和replaced-method比较陌生,怎么玩的?
  15. Spring系列第15篇:代理详解(Java动态代理&cglib代理)?
  16. Spring系列第16篇:深入理解java注解及spring对注解的增强(预备知识)
  17. Spring系列第17篇:@Configration和@Bean注解详解(bean批量注册)
  18. Spring系列第18篇:@ComponentScan、@ComponentScans详解(bean批量注册)
  19. Spring系列第18篇:@import详解(bean批量注册)
  20. Spring系列第20篇:@Conditional通过条件来控制bean的注册
  21. Spring系列第21篇:注解实现依赖注入(@Autowired、@Resource、@Primary、@Qulifier)
  22. Spring系列第22篇:@Scope、@DependsOn、@ImportResource、@Lazy 详解
  23. Spring系列第23篇:Bean生命周期详解
  24. Spring系列第24篇:父子容器详解
  25. Spring系列第25篇:@Value【用法、数据来源、动态刷新】
  26. Spring系列第26篇:国际化详解
  27. Spring系列第27篇:spring事件机制详解
  28. Spring系列第28篇:Bean循环依赖详解
  29. Spring系列第29篇:BeanFactory扩展(BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor)
  30. Spring系列第30篇:jdk动态代理和cglib代理
  31. Spring系列第31篇:aop概念详解
  32. Spring系列第32篇:AOP核心源码、原理详解
  33. Spring系列第33篇:ProxyFactoryBean创建AOP代理
  34. Spring系列第34篇:@Aspect中@Pointcut 12种用法
  35. Spring系列第35篇:@Aspect中5中通知详解
  36. Spring系列第36篇:@EnableAspectJAutoProxy、@Aspect中通知顺序详解
  37. Spring系列第37篇:@EnableAsync & @Async 实现方法异步调用
  38. Spring系列第38篇:@Scheduled & @EnableScheduling定时器详解
  39. Spring系列第39篇:强大的Spel表达式
  40. Spring系列第40篇:缓存使用(@EnableCaching、@Cacheable、@CachePut、@CacheEvict、@Caching、@CacheConfig)
  41. Spring系列第41篇:@EnableCaching集成redis缓存
  42. Spring系列第42篇:玩转JdbcTemplate
  43. Spring系列第43篇:spring中编程式事务怎么用的?
  44. Spring系列第44篇:详解spring声明式事务(@Transactional)
  45. Spring系列第45篇:带你吃透Spring事务7种传播行为
  46. Spring系列第46篇:Spring如何管理多数据源事务?
  47. Spring系列第47篇:spring编程式事务源码解析
  48. Spring系列第48篇:@Transaction 事务源码解析
  49. Spring系列第49篇:通过Spring事务实现MQ中的事务消息
  50. Spring系列第50篇:spring事务拦截器顺序如何控制?
  51. Spring系列第51篇:导致 Spring 事务失效常见的几种情况
  52. Spring系列第52篇:Spring实现数据库读写分离
  53. Spring系列第53篇:Spring集成MyBatis

8、更多好文章

  1. Java高并发系列(共34篇)
  2. MySql高手系列(共27篇)
  3. Maven高手系列(共10篇)
  4. Mybatis系列(共12篇)
  5. 聊聊db和缓存一致性常见的实现方式
  6. 接口幂等性这么重要,它是什么?怎么实现?
  7. 泛型,有点难度,会让很多人懵逼,那是因为你没有看这篇文章!

9、福利

这边整理了几百本计算机相关的电子书,下面是部分截图,常见的基本上都有,获取方式,扫描文末二维码,发送:电子书

file

正文到此结束
本文目录