一个比较好的Processor

主要用于经常做一些多维度处理，通过处理类的实现，能够满足代码的精简和美观

1.接口Processor

package com.lxp.processor;

/**
 * 处理接口，抽象类A继承这个接口，实现其中方法，具体业务抽象类B继承A，具体业务逻辑类C继承抽象类B,C中一般就可以做相关的具体的
 * 逻辑内容，比如数据库dao操作、其它数据结构的内容存储
 */
public interface Processor<T> {
	public void process(T context) throws Exception;
}

2.接口实现抽象类AbstractProcessor

package com.lxp.processor;

/**
 * 不能直接被实现类所继承，需要以抽象类来继承，以归类各个processor，其它所有的业务抽象processor都继承这个，
 * 具体实用类，通过调用process方法，去调用子类的doProcess方法，
 * 
 */
public abstract class AbstractProcessor<T> implements Processor<T>{
	public void process(T context) throws Exception {
		if(needRun(context)) {
			validate(context);
			doProcess(context);
		}
	}
	
	protected abstract void doProcess(T context) throws Exception;
	
	protected void validate(T context) {
		if(null == context) {
			throw new IllegalArgumentException("ProcessContext must not be null");
		}
	}
	
	protected boolean needRun(T context) {
		return true;
	}
}

3.业务抽象类

（1）查询

package com.lxp.processor.query;

import com.lxp.context.UserInfoContext;
import com.lxp.processor.AbstractProcessor;

public abstract class QueryUserInfoAbstractProcessor<T extends UserInfoContext> extends AbstractProcessor<T>{
}

（2）更新

package com.lxp.processor.update;

import com.lxp.context.UserInfoContext;
import com.lxp.processor.AbstractProcessor;

public abstract class UpdateUserInfoAbstractProcessor<T extends UserInfoContext> extends AbstractProcessor<T>{
}

4.业务具体逻辑类

（1）查询

package com.lxp.processor.query;

import java.util.List;

import com.lxp.context.UserInfoContext;
import com.lxp.processor.Processor;


public class QueryUserInfoProcessor extends QueryUserInfoAbstractProcessor<UserInfoContext>{
	
	private List<Processor<UserInfoContext>> userInfoProcessors;
	
	/**
	 * 由于是protected，所以该方法只能被继承类获取处理，普通的类是无法看到该方法的，但是可以看到process方法，这样就能够通过父类process方法，调用doProcess方法
	 * 该doProcess方法中可以做一些具体的逻辑处理，用于context使用
	 */
	@Override
	protected void doProcess(UserInfoContext context) throws Exception {
		for(Processor<UserInfoContext> userInfoProcessor:userInfoProcessors) {
			userInfoProcessor.process(context);
		}
	}
}

（2）更新

package com.lxp.processor.update;

import java.util.List;

import com.lxp.context.UserInfoContext;
import com.lxp.processor.Processor;


public class UpdateUserInfoProcessor extends UpdateUserInfoAbstractProcessor<UserInfoContext>{
	
	
	/**
	 * 由于是protected，所以该方法只能被继承类获取处理，普通的类是无法看到该方法的，但是可以看到process方法，这样就能够通过父类process方法，调用doProcess方法
	 * 该doProcess方法中可以做一些具体的逻辑处理，用于context使用
	 */
	@Override
	protected void doProcess(UserInfoContext context) throws Exception {
		if(context.getUserIdList()!=null) {
//			context.setUserInfoList(/*根据UserIdList获取UserIdList信息，操作数据库*/);
//			一般就可以在Processor具体类中做一些dao的操作或者其它一些context数据处理
		}
	}
}

5.context类

package com.lxp.context;

import java.util.List;

import com.lxp.dto.UserInfoDto;

public class UserInfoContext {
	private List<UserInfoDto> userInfoList;
	private List<Long> userIdList;
	public List<UserInfoDto> getUserInfoList() {
		return userInfoList;
	}
	public void setUserInfoList(List<UserInfoDto> userInfoList) {
		this.userInfoList = userInfoList;
	}
	public List<Long> getUserIdList() {
		return userIdList;
	}
	public void setUserIdList(List<Long> userIdList) {
		this.userIdList = userIdList;
	}
}

6.dto类

package com.lxp.dto;

public class UserInfoDto {
	private Long id;
	private String name;
	private String age;
	private String address;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
}