Spring 소스 코드 의 디자인

패턴 종류
        Spring 의 소스 코드 에서 다음 코드 를 보 았 는데 사용 방법 이 매우 교묘 하 게 느껴 져 기록 해 보 세 요.
ReflectiveAspectJAdvisorFactory：

	private List getAdvisorMethods(Class> aspectClass) {
		final List methods = new LinkedList();
		//              ：ReflectionUtils.MethodCallback()
		// 1，MethodCallback           ，                  。
		// 2，                  ，          ，           。
		//            Method    ，             ：        ，              。
		ReflectionUtils.doWithMethods(aspectClass, new ReflectionUtils.MethodCallback() {
			@Override
			public void doWith(Method method) throws IllegalArgumentException {
				// Exclude pointcuts
				if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
					methods.add(method);
				}
			}
		});
		Collections.sort(methods, METHOD_COMPARATOR);
		return methods;
	}

다음은 ReflectionUtils. doWithMethods 에서 호출 된 doWithMethods 방법의 실현 을 살 펴 보 겠 습 니 다.

	public static void doWithMethods(Class> clazz, MethodCallback mc, MethodFilter mf) {
		// Keep backing up the inheritance hierarchy.
		Method[] methods = getDeclaredMethods(clazz);
		for (Method method : methods) {
			if (mf != null && !mf.matches(method)) {
				continue;
			}
			try {
				//                    
				//     Method  
				mc.doWith(method);
			}
			catch (IllegalAccessException ex) {
				throw new IllegalStateException("Not allowed to access method '" + method.getName() + "': " + ex);
			}
		}
		if (clazz.getSuperclass() != null) {
			doWithMethods(clazz.getSuperclass(), mc, mf);
		}
		else if (clazz.isInterface()) {
			for (Class> superIfc : clazz.getInterfaces()) {
				doWithMethods(superIfc, mc, mf);
			}
		}
	}

패턴 사용    
        이런 모드 는 어디 에 사용 합 니까?이 모드 와 템 플 릿 모드 가 비슷 한 것 같 습 니 다. 공 통 된 처 리 를 집중 시 키 고 특수 처 리 를 인터페이스 로 써 서 사용 하 는 곳 에서 스스로 실현 하도록 합 니 다.인 터 페 이 스 를 실현 하 는 곳 에서 자신 이 하고 싶 은 일 을 할 수 있다. 예 를 들 어:

맞 춤 형 조건 으로 다른 집합 에서 조건 에 부합 되 는 데 이 터 를 얻는다

우리 가 하고 싶 은 처 리 를 집행 한다

"우리 가 하고 싶 은 처 리 를 수행 합 니 다" 라 는 사용 방법 은 한 번 해 본 적 이 있 습 니 다.Mybatis 와 Mysql 을 사용 하 는 시스템 에 서 는 일괄 삽입 을 해 야 합 니 다.DAO 방법 은 주석 (@ Insert) 으로 쓴 것 입 니 다. 예 를 들 어:
    @(Insert "Insert Into XXX ......")
    void insertUserInfo(User user);
많은 부분 에서 이렇게 써 야 하기 때문에 추상 류, 추상 류 의 역할 을 썼 다.

순환 을 제어 한다.예 를 들 어 10000 삽입 후 한 번 Batch

를 실행 합 니 다.

사용자 에 게 자신 이 실행 하고 자 하 는 DAO 방법 을 적 으 면 되 는 리 셋 을 폭로 했다.

다음 과 같이 구현:

public abstract class AbstractBatchCommit {

    /**
     *    N          
     * @author shijiapeng
     * @date 2016 9 22 
     * @param list
     */
    public void commitBatch(List list) {
        try{
            //     N    List
            List commitList = new ArrayList(Constants.BATCH_COMMIT_SIZE);
            for(int idx = 0; idx < list.size(); idx++){
                commitList.add(list.get(idx));
                //  N          
                if(idx !=0 && (idx + 1)%Constants.BATCH_COMMIT_SIZE == 0){
                    //        
                    callSQL(commitList);
                    //   list
                    commitList.clear();
                }
            }
            
            //   N ,  N       ,    
            if(!commitList.isEmpty()){
                callSQL(commitList);
            }
            
        } catch(Exception e){
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    
    /*
     *   SQL  
     */
    public abstract void callSQL(List list) throws SQLException;
}