TDD实践（一）

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了TDD实践（一），前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

@H_502_2@一.TDD概述

TDD：测试驱动开发，它的基本思想就是在开发功能代码之前，先编写测试代码。也就是说在明确要开发某个功能后，首先思考如何对这个功能进行测试，并完成测试代码的编写，然后编写相关的代码满足这些测试用例。然后循环进行添加其他功能，直到完全部功能的开发。

TDD的基本思路就是通过测试来推动整个开发的进行。

需求向来就是软件开发过程中感觉最不好明确描述、易变的东西。这里说的需求不只是指用户的需求，还包括对代码的使用需求。很多开发人员最害怕的就是后期还要修改某个类或者函数的接口进行修改或者扩展，为什么会发生这样的事情就是因为这部分代码的使用需求没有很好的描述。测试驱动开发就是通过编写测试用例，先考虑代码的使用需求（包括功能、过程、接口等），而且这个描述是无二义的，可执行验证的。

通过编写这部分代码的测试用例，对其功能的分解、使用过程、接口都进行了设计。而且这种从使用角度对代码的设计通常更符合后期开发的需求。可测试的要求，对代码的内聚性的提高和复用都非常有益。因此测试驱动开发也是一种代码设计的过程。

开发人员通常对编写文档非常厌烦，但要使用、理解别人的代码时通常又希望能有文档进行指导。而测试驱动开发过程中产生的测试用例代码就是对代码的最好的解释。

当然测试驱动开发最重要的功能还在于保障代码的正确性，能够迅速发现、定位bug。而迅速发现、定位bug是很多开发人员的梦想。针对关键代码的测试集，以及不断完善的测试用例，为迅速发现、定位bug提供了条件。

实践一段功能比较复杂的代码使用TDD开发完成，只发现几个bug，而且很快能定位解决。我相信，如果在实际工作中运用TDD，也一定会有这种自信的开发过程，功能不断增加、完善的感觉，迅速发现、定位bug的能力。

@H_502_2@二.TDD实战练习

说明：这是一个停车场练习，需求是软件运行一段时间后，用户再次提出来的。

@H_502_2@需求1：要一个停车场，有一定数目的停车位，能停车取车，如果车停满了就不能停了，在停满的情况下取一辆车后就能再停一辆进来。

TDD具体开发过程：先写一个测试失败的测试案例，然后编写代码让这个测试案例通过，再重构，重构完成后再写一个测试失败的测试案例......直到需求要求的功能开发完成。

PackLogTest.java

  1. package com.bijian.test;
  2.  
  3. import junit.framework.Assert;
  4.  
  5. import org.junit.Before;
  6. import org.junit.Test;
  7.  
  8. import com.bijian.study.PackLog;
  9.  
  10. public class PackLogTest {    
  11. 	
  12. 	private PackLog packLog;
  13. 	
  14.     @Before
  15.     public void setUp() throws Exception {
  16.         packLog = new PackLog("X",10);
  17.     }
  18.  
  19.     @Test
  20.     public void test_normal_stop_a_car() {
  21.     	String vehicleCode = "粤B-123456";
  22.     	
  23.     	packLog.stopCar(vehicleCode);
  24.     	int remainStopCarNum = packLog.getRemainStopCarNum();
  25.     	
  26.         Assert.assertEquals(10-1,remainStopCarNum);
  27.     }
  28.     
  29.     @Test
  30.     public void test_normal_stop_a_car_then_get() {
  31.     	String vehicleCode = "粤B-123456";
  32.     	
  33.     	packLog.stopCar(vehicleCode);
  34.     	packLog.getCar("粤B-123456");
  35.     	int remainStopCarNum = packLog.getRemainStopCarNum();
  36.     	
  37.     	Assert.assertEquals(10+1-1,remainStopCarNum);	
  38.     }
  39.     
  40.     private void given_init_data_for_packLog(int num) {
  41. 		for(int i=0;i<num;i++) {
  42. 			packLog.stopCar("粤B-00000" + i);
  43. 		}
  44. 	}
  45.     
  46.     @Test
  47.     public void test_full_packlog_then_stop_car_fail() {
  48.     	
  49.     	given_init_data_for_packLog(10);
  50.     	
  51.     	String vehicleCode = "粤B-123456";
  52.     	packLog.stopCar(vehicleCode);
  53.     	int remainStopCarNum = packLog.getRemainStopCarNum();
  54.     	boolean isStopInThisPackLog = packLog.isStopInThisPackLog(vehicleCode);
  55.     	
  56.     	Assert.assertEquals(0,remainStopCarNum);
  57.     	Assert.assertFalse(isStopInThisPackLog);
  58.     }
  59.     
  60.     @Test
  61.     public void test_full_packlog_then_stop_car_success_after_get_a_car() {
  62.     	
  63.     	given_init_data_for_packLog(9);
  64.     	String vehicleCode = "粤B-123456";
  65.     	packLog.stopCar(vehicleCode);
  66.     	
  67.     	packLog.getCar(vehicleCode);
  68.     	String vehicleCode2 = "粤B-333333";
  69.     	packLog.stopCar(vehicleCode2);
  70.     	int remainStopCarNum = packLog.getRemainStopCarNum();
  71.     	boolean isStopInThisPackLog = packLog.isStopInThisPackLog(vehicleCode2);
  72.     	
  73.     	Assert.assertEquals(0,remainStopCarNum);
  74.     	Assert.assertTrue(isStopInThisPackLog);
  75.     }
  76.     
  77.     @Test
  78.     public void test_empty_packlog_then_get_car() {
  79.     	
  80.     	String vehicleCode = "粤B-123456";
  81.     	String resVehicleCode = packLog.getCar(vehicleCode);
  82.     	
  83.     	int remainStopCarNum = packLog.getRemainStopCarNum();
  84.     	
  85.     	Assert.assertNull(resVehicleCode);
  86.     	Assert.assertEquals(10,remainStopCarNum);
  87.     }
  88. }

PackLog.java

  1. package com.bijian.study;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5.  
  6. public class PackLog {
  7.  
  8. 	//停车场名称
  9. 	private String name;
  10. 	//停车场车位总数量
  11. 	private int totalStopCarNum;
  12. 	
  13. 	private Map<String,String> stopCarMap;
  14.  
  15. 	public PackLog(String name,int stopCarNum) {
  16. 		this.name = name;
  17. 		this.totalStopCarNum = stopCarNum;
  18. 		stopCarMap = new HashMap<String,String>(stopCarNum);
  19. 	}
  20. 	
  21. 	public synchronized void stopCar(String vehicleCode) {
  22. 		if(stopCarMap.size() < totalStopCarNum) {
  23. 			stopCarMap.put(vehicleCode,vehicleCode);
  24. 		}
  25. 	}
  26. 	
  27. 	public synchronized String getCar(String vehicleCode) {
  28. 		return stopCarMap.remove(vehicleCode);
  29. 	}
  30. 	
  31. 	public int getRemainStopCarNum() {
  32. 		return (totalStopCarNum - this.stopCarMap.size()) ;
  33. 	}
  34. 	
  35. 	public boolean isStopInThisPackLog(String vehicleCode) {
  36. 		if(stopCarMap == null || stopCarMap.size() == 0) {
  37. 			return false;
  38. 		}
  39. 		return stopCarMap.containsKey(vehicleCode);
  40. 	}
  41. 	
  42. 	public String getName() {
  43. 		return name;
  44. 	}
  45. }

@H_502_2@需求2：有多个需求1那样的停车场，这多个停车场交由一个管理员统一管理，哪个停车场有车位，就将车停到哪个停车场。

Employee.java

  1. package com.bijian.study;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. public class Employee {
  7. 	
  8. 	private List<PackLog> packLogs = new ArrayList<PackLog>();
  9. 	
  10. 	public void addPackLog(PackLog packLog) {
  11. 		packLogs.add(packLog);
  12. 	}
  13. 	
  14. 	public void stopCar(String vehicleCode) {
  15. 		PackLog packLog = getPackLog(packLogs);
  16. 		if(packLog == null) {
  17. 			return;
  18. 		}
  19. 		packLog.stopCar(vehicleCode);
  20. 	}
  21. 	
  22. 	public String getCar(String vehicleCode) {
  23. 		String vehicleCodeRes = null;
  24. 		for(PackLog packLog: packLogs) {
  25. 			vehicleCodeRes = packLog.getCar(vehicleCode);
  26. 			if(vehicleCodeRes != null) {
  27. 				break;
  28. 			}
  29. 		}
  30. 		return vehicleCodeRes;
  31. 	}
  32. 	
  33. 	public PackLog getPackLog(List<PackLog> packLogs){
  34. 		
  35. 		for(PackLog packLog: packLogs) {
  36. 			if(packLog.getRemainStopCarNum()>0) {
  37. 				return packLog;
  38. 			}
  39. 		}
  40. 		return null;
  41. 	}
  42. }

EmployeeTest.java

  1. package com.bijian.test;
  2.  
  3. import junit.framework.Assert;
  4.  
  5. import org.junit.Before;
  6. import org.junit.Test;
  7.  
  8. import com.bijian.study.Employee;
  9. import com.bijian.study.PackLog;
  10.  
  11. public class EmployeeTest {
  12.  
  13. 	private Employee employee;
  14. 	private PackLog packLog1;
  15. 	private PackLog packLog2;
  16. 	
  17.     @Before
  18.     public void setUp() throws Exception {
  19.     	employee = new Employee();
  20.     	packLog1 = new PackLog("X",1);
  21.     	packLog2 = new PackLog("Y",2);
  22.     	employee.addPackLog(packLog1);
  23.     	employee.addPackLog(packLog2);
  24.     }
  25.  
  26.     @Test
  27.     public void test_normal_stop_car() {
  28.     	
  29.     	String vehicleCode = "粤B-123456";
  30.     	employee.stopCar(vehicleCode);
  31.     	
  32.         Assert.assertEquals("X",packLog1.getName());
  33.         Assert.assertEquals(1-1,packLog1.getRemainStopCarNum());
  34.         Assert.assertEquals("Y",packLog2.getName());
  35.         Assert.assertEquals(2-0,packLog2.getRemainStopCarNum());
  36.     }
  37.     
  38.     @Test
  39.     public void test_normal_get_car() {
  40.     	
  41.     	String vehicleCode = "粤B-123456";
  42.     	employee.stopCar(vehicleCode);
  43.     	String vehicleCodeRes = employee.getCar("粤B-123456");
  44.     	
  45.     	Assert.assertEquals("粤B-123456",vehicleCodeRes);
  46.     	Assert.assertEquals("X",packLog1.getName());
  47.         Assert.assertEquals(1-0,packLog2.getRemainStopCarNum());
  48.     }
  49.     
  50.     private void given_init_data_for_packLog1(int num) {
  51.     	for(int i=0;i<num;i++) {
  52. 			packLog1.stopCar("粤B-00000" + i);
  53. 		}
  54.     }
  55.     
  56.     private void given_init_data_for_packLog2(int num) {
  57.     	for(int i=0;i<num;i++) {
  58. 			packLog2.stopCar("粤B-00001" + i);
  59. 		}
  60.     }
  61.     
  62.     @Test
  63.     public void test_full_packlog_then_stop_car_fail() {
  64.     	
  65.     	given_init_data_for_packLog1(1);
  66.     	given_init_data_for_packLog2(2);
  67.     	
  68.     	String vehicleCode = "粤B-123456";
  69.     	employee.stopCar(vehicleCode);
  70.     	String vehicleCodeRes = employee.getCar("粤B-123456");
  71.     	
  72.     	Assert.assertNull(vehicleCodeRes);
  73.     	Assert.assertEquals("X",packLog1.getName());
  74.         Assert.assertEquals(0,packLog2.getName());
  75.         Assert.assertEquals(0,packLog2.getRemainStopCarNum());
  76.     }
  77.     
  78.     @Test
  79.     public void test_full_packlog_then_stop_car_success_after_get_a_car() {
  80.     	
  81.     	given_init_data_for_packLog1(1);
  82.     	given_init_data_for_packLog2(1);
  83.     	String vehicleCode = "粤B-123456";
  84.     	employee.stopCar(vehicleCode);
  85.     	
  86.     	employee.getCar(vehicleCode);
  87.     	String vehicleCode2 = "粤B-333333";
  88.     	employee.stopCar(vehicleCode2);
  89.     	int packLog1RemainStopCarNum = packLog1.getRemainStopCarNum();
  90.     	int packLog2RemainStopCarNum = packLog2.getRemainStopCarNum();
  91.     	boolean isStopInThisPackLog = packLog2.isStopInThisPackLog(vehicleCode2);
  92.     	
  93.     	Assert.assertEquals(0,packLog1RemainStopCarNum);
  94.     	Assert.assertEquals(0,packLog2RemainStopCarNum);
  95.     	Assert.assertTrue(isStopInThisPackLog);
  96.     }
  97.     
  98.     @Test
  99.     public void test_empty_packlog_then_get_car() {
  100.     	
  101.     	String vehicleCode = "粤B-123456";
  102.     	String resVehicleCode = employee.getCar(vehicleCode);
  103.     	
  104.     	int packLog1RemainStopCarNum = packLog1.getRemainStopCarNum();
  105.     	int packLog2RemainStopCarNum = packLog2.getRemainStopCarNum();
  106.     	
  107.     	Assert.assertNull(resVehicleCode);
  108.     	Assert.assertEquals(1,packLog1RemainStopCarNum);
  109.     	Assert.assertEquals(2,packLog2RemainStopCarNum);
  110.     }
  111. }

@H_502_2@需求3：又聘请了一位聪明的管理员，当有车停进来时，他会判断当前这些停车场，哪个停车场剩余的车位多，就将车停到哪个停车场。

采用继承机制实现：

SmartEmployee.java

  1. package com.bijian.study;
  2.  
  3. import java.util.List;
  4.  
  5. public class SmartEmployee extends Employee {
  6. 	
  7. 	public PackLog getPackLog(List<PackLog> packLogs){
  8. 		int res = 0;
  9. 		PackLog packLogRes = null;
  10. 		for(PackLog packLog: packLogs) {
  11. 			int currentPackLogNum = packLog.getRemainStopCarNum();
  12. 			res = currentPackLogNum > res ? currentPackLogNum : res;
  13. 			packLogRes = packLog;
  14. 		}
  15. 		return packLogRes;
  16. 	}
  17. }

SmartEmployeeTest.java

  1. package com.bijian.test;
  2.  
  3. import junit.framework.Assert;
  4.  
  5. import org.junit.Before;
  6. import org.junit.Test;
  7.  
  8. import com.bijian.study.PackLog;
  9. import com.bijian.study.SmartEmployee;
  10.  
  11. public class SmartEmployeeTest {
  12.  
  13. 	private SmartEmployee smartEmployee;
  14. 	private PackLog packLog1;
  15. 	private PackLog packLog2;
  16. 	
  17.     @Before
  18.     public void setUp() throws Exception {
  19.     	smartEmployee = new SmartEmployee();
  20.     	packLog1 = new PackLog("X",2);
  21.     	smartEmployee.addPackLog(packLog1);
  22.     	smartEmployee.addPackLog(packLog2);
  23.     }
  24.  
  25.     @Test
  26.     public void test_normal_stop_car() {
  27.     	String vehicleCode = "粤B-123456";
  28.     	smartEmployee.stopCar(vehicleCode);
  29.     	
  30.     	Assert.assertEquals("X",packLog2.getName());
  31.         Assert.assertEquals(2-1,packLog2.getRemainStopCarNum());
  32.     }
  33.     
  34.     @Test
  35.     public void test_normal_get_car() {
  36.     	String vehicleCode = "粤B-123456";
  37.     	smartEmployee.stopCar(vehicleCode);
  38.     	String vehicleCodeRes = smartEmployee.getCar(vehicleCode);
  39.         
  40.         Assert.assertEquals("粤B-123456",packLog2.getRemainStopCarNum());
  41.     }
  42.     
  43.     private void given_init_data_for_packLog1(int num) {
  44.     	for(int i=0;i<num;i++) {
  45. 			packLog1.stopCar("粤B-00000" + i);
  46. 		}
  47.     }
  48.     
  49.     private void given_init_data_for_packLog2(int num) {
  50.     	for(int i=0;i<num;i++) {
  51. 			packLog2.stopCar("粤B-00001" + i);
  52. 		}
  53.     }
  54.     
  55.     @Test
  56.     public void test_full_packlog_then_stop_car_fail() {
  57.     	
  58.     	given_init_data_for_packLog1(1);
  59.     	given_init_data_for_packLog2(2);
  60.     	
  61.     	String vehicleCode = "粤B-123456";
  62.     	smartEmployee.stopCar(vehicleCode);
  63.     	String vehicleCodeRes = smartEmployee.getCar("粤B-123456");
  64.     	
  65.     	Assert.assertNull(vehicleCodeRes);
  66.     	Assert.assertEquals("X",packLog2.getRemainStopCarNum());
  67.     }
  68.     
  69.     @Test
  70.     public void test_full_packlog_then_stop_car_success_after_get_a_car() {
  71.     	
  72.     	given_init_data_for_packLog1(1);
  73.     	given_init_data_for_packLog2(1);
  74.     	String vehicleCode = "粤B-123456";
  75.     	smartEmployee.stopCar(vehicleCode);
  76.     	
  77.     	smartEmployee.getCar(vehicleCode);
  78.     	String vehicleCode2 = "粤B-333333";
  79.     	smartEmployee.stopCar(vehicleCode2);
  80.     	int packLog1RemainStopCarNum = packLog1.getRemainStopCarNum();
  81.     	int packLog2RemainStopCarNum = packLog2.getRemainStopCarNum();
  82.     	boolean isStopInThisPackLog = packLog2.isStopInThisPackLog(vehicleCode2);
  83.     	
  84.     	Assert.assertEquals(0,packLog2RemainStopCarNum);
  85.     	Assert.assertTrue(isStopInThisPackLog);
  86.     }
  87.     
  88.     @Test
  89.     public void test_empty_packlog_then_get_car() {
  90.     	
  91.     	String vehicleCode = "粤B-123456";
  92.     	String resVehicleCode = smartEmployee.getCar(vehicleCode);
  93.     	
  94.     	int packLog1RemainStopCarNum = packLog1.getRemainStopCarNum();
  95.     	int packLog2RemainStopCarNum = packLog2.getRemainStopCarNum();
  96.     	
  97.     	Assert.assertNull(resVehicleCode);
  98.     	Assert.assertEquals(1,packLog2RemainStopCarNum);
  99.     }
  100. }

@H_502_2@三.小结

1.单元测试

a.单元测试三步骤：准备数据、测试、检验结果

b.单元测试方法命名采用：Given_When_Then方式

c.类中不要有set方法，如果用初始化测试数据，采用私有方法，即givenXXX()方法初始化数据

2.如上第三个需求采用OO中的继承实现，也可以采用高大上点的方式实现，即运用策略模式，如下所示：

IStrategy.java

  1. package com.bijian.study;
  2.  
  3. import java.util.List;
  4.  
  5. public interface IStrategy {
  6.  
  7. 	public PackLog getSuitablePackLog(List<PackLog> packLogs);
  8. }

CommonStrategy.java

  1. package com.bijian.study;
  2.  
  3. import java.util.List;
  4.  
  5. public class CommonStrategy implements IStrategy {
  6.  
  7. 	@Override
  8. 	public PackLog getSuitablePackLog(List<PackLog> packLogs) {
  9. 		for(PackLog packLog: packLogs) {
  10. 			if(packLog.getRemainStopCarNum()>0) {
  11. 				return packLog;
  12. 			}
  13. 		}
  14. 		return null;
  15. 	}
  16.  
  17. }

SmartStrategy.java

  1. package com.bijian.study;
  2.  
  3. import java.util.List;
  4.  
  5. public class SmartStrategy implements IStrategy {
  6.  
  7. 	@Override
  8. 	public PackLog getSuitablePackLog(List<PackLog> packLogs) {
  9. 		int res = 0;
  10. 		PackLog packLogRes = null;
  11. 		for(PackLog packLog: packLogs) {
  12. 			int currentPackLogNum = packLog.getRemainStopCarNum();
  13. 			res = currentPackLogNum > res ? currentPackLogNum : res;
  14. 			packLogRes = packLog;
  15. 		}
  16. 		return packLogRes;
  17. 	}
  18. }

Employee.java

  1. package com.bijian.study;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. public class Employee {
  7.  
  8. 	private List<PackLog> packLogs = new ArrayList<PackLog>();
  9. 	private IStrategy strategy;
  10. 	
  11. 	public Employee(IStrategy strategy) {
  12. 		this.strategy = strategy;
  13. 	}
  14. 	
  15. 	public void addPackLog(PackLog packLog) {
  16. 		packLogs.add(packLog);
  17. 	}
  18. 	
  19. 	public void stopCar(String vehicleCode) {
  20. 		PackLog packLog = strategy.getSuitablePackLog(packLogs);
  21. 		if(packLog == null) {
  22. 			return;
  23. 		}
  24. 		packLog.stopCar(vehicleCode);
  25. 	}
  26. 	
  27. 	public String getCar(String vehicleCode) {
  28. 		String vehicleCodeRes = null;
  29. 		for(PackLog packLog: packLogs) {
  30. 			vehicleCodeRes = packLog.getCar(vehicleCode);
  31. 			if(vehicleCodeRes != null) {
  32. 				break;
  33. 			}
  34. 		}
  35. 		return vehicleCodeRes;
  36. 	}
  37. }

单元测试除了@Before中的构建Employee有点变化之外，其它都没变，如下所示：

EmployeeTest.java

  1. package com.bijian.test;
  2.  
  3. import junit.framework.Assert;
  4.  
  5. import org.junit.Before;
  6. import org.junit.Test;
  7.  
  8. import com.bijian.study.CommonStrategy;
  9. import com.bijian.study.Employee;
  10. import com.bijian.study.PackLog;
  11.  
  12. public class EmployeeTest {
  13.  
  14. 	private Employee employee;
  15. 	private PackLog packLog1;
  16. 	private PackLog packLog2;
  17. 	
  18.     @Before
  19.     public void setUp() throws Exception {
  20.     	employee = new Employee(new CommonStrategy());
  21.     	packLog1 = new PackLog("X",packLog2RemainStopCarNum);
  22.     }
  23. }

SmartEmployeeTest.java

  1. package com.bijian.test;
  2.  
  3. import junit.framework.Assert;
  4.  
  5. import org.junit.Before;
  6. import org.junit.Test;
  7.  
  8. import com.bijian.study.Employee;
  9. import com.bijian.study.PackLog;
  10. import com.bijian.study.SmartStrategy;
  11.  
  12. public class SmartEmployeeTest {
  13.  
  14. 	private Employee smartEmployee;
  15. 	private PackLog packLog1;
  16. 	private PackLog packLog2;
  17. 	
  18.     @Before
  19.     public void setUp() throws Exception {
  20.     	smartEmployee = new Employee(new SmartStrategy());
  21.     	packLog1 = new PackLog("X",packLog2RemainStopCarNum);
  22.     }
  23. }

敏捷教练：http://www.jackyshen.com/

猜你在找的设计模式相关文章

适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript