java在spring框架下实现Service工厂类

    今天维护一下之前写的数据库表的备份还原功能，想把自己写的spring工厂类，以及数据库备份还原功能记录一下！复制粘贴到自己本地，是运行不了的，我这里只提供思路，毕竟我这里引用的是谷歌的gson的jia包和自己项目里有的Service类。大家可以根据思路，自己写需要的工厂类实现。

    1.首先，展示一下，自己的工厂类代码：

package com.iyunxiao.dora.service.impl;

import com.google.gson.reflect.TypeToken;
import com.iyunxiao.dora.domain.*;
import com.iyunxiao.dora.domain.CoursePlanChangeHistory;
import com.iyunxiao.dora.domain.po.*;
import com.iyunxiao.dora.domain.vo.ClassRoomCourseVO;
import com.iyunxiao.dora.service.*;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author dengjingsi
 * @date $ $
 * @ClassName MapperFactory
 * @Description TODO
 **/
@Component
public class MapperFactory {
    public static Map<String, Type> tableMap = new HashMap<>();//标记备份表与类对应的关系，通过key值反射成相关的service,value为数据转换json类型用

    static {
        tableMap.put("classInfo", new TypeToken<List<ClassInfo>>() {
        }.getType());//添加班级信息->Json转换对象类型映射
        tableMap.put("classGroup", new TypeToken<List<ClassGroup>>() {
        }.getType());
        tableMap.put("course", new TypeToken<List<Course>>() {
        }.getType());
        tableMap.put("classGroupClass", new TypeToken<List<ClassGroupClass>>() {
        }.getType());
        tableMap.put("ClassCourseTeacher", new TypeToken<List<ClassCourseTeacher>>() {
        }.getType());
        tableMap.put("ClassRoom", new TypeToken<List<ClassRoomPO>>() {
        }.getType());
        tableMap.put("ClassRoomCourse", new TypeToken<List<ClassRoomCourseVO>>() {
        }.getType());
        tableMap.put("conditionSettings", new TypeToken<List<ConditionSettingsPO>>() {
        }.getType());
        tableMap.put("CourseTeacher", new TypeToken<List<CourseTeacher>>() {
        }.getType());
        tableMap.put("CoursePlan", new TypeToken<List<CoursePlanPO>>() {
        }.getType());
        tableMap.put("CourseGroup", new TypeToken<List<CourseGroupCourse>>() {
        }.getType());
        tableMap.put("CoursePlanChangeHistory", new TypeToken<List<CoursePlanChangeHistory>>() {
        }.getType());
        tableMap.put("CoursePlanScore", new TypeToken<List<CoursePlanScore>>() {
        }.getType());
        tableMap.put("ElectiveLessonTimeClassGroup", new TypeToken<List<ElectivelessonTimeClassGroupPOJO>>() {
        }.getType());
        tableMap.put("ElectiveLessonTimeClassGroupCheckResult", new TypeToken<List<ElectiveLessonTimeClassGroupCheckResult>>() {
        }.getType());
        tableMap.put("ElectiveLessonTimeClassGroupCoursePlan", new TypeToken<List<ElectiveLessonTimeClassGroupCoursePlanPOJO>>() {
        }.getType());
        tableMap.put("Grade", new TypeToken<List<Grade>>() {
        }.getType());
        tableMap.put("Rule", new TypeToken<List<RulePO>>() {
        }.getType());
        tableMap.put("RunningTask", new TypeToken<List<RunningTaskPO>>() {
        }.getType());
        tableMap.put("ScheduleTime", new TypeToken<List<ScheduleTime>>() {
        }.getType());
        tableMap.put("Student", new TypeToken<List<Student>>() {
        }.getType());
        tableMap.put("StudentClassGroup", new TypeToken<List<StudentClassGroupPO>>() {
        }.getType());
        tableMap.put("StudentCourse", new TypeToken<List<StudentCourse>>() {
        }.getType());
        tableMap.put("StudentScore", new TypeToken<List<StudentScore>>() {
        }.getType());
        tableMap.put("Subject", new TypeToken<List<Subject>>() {
        }.getType());
        tableMap.put("TagInfo", new TypeToken<List<TagInfo>>() {
        }.getType());
        tableMap.put("TagRule", new TypeToken<List<TagRule>>() {
        }.getType());
        tableMap.put("TaskQueue", new TypeToken<List<TaskQueue>>() {
        }.getType());
        tableMap.put("TaskResult", new TypeToken<List<TaskResult>>() {
        }.getType());
        tableMap.put("TaskResultData", new TypeToken<List<TaskResultData>>() {
        }.getType());
        tableMap.put("TaskRule", new TypeToken<List<TaskRule>>() {
        }.getType());
        //tableMap.put("TaskShare", new TypeToken<List<TaskShare>>(){}.getType());协作
        tableMap.put("Teacher", new TypeToken<List<Teacher>>() {
        }.getType());
        tableMap.put("AlgorithmParameter", new TypeToken<List<AlgorithmParameter>>() {
        }.getType());
        tableMap.put("electiveAssignStudentClass", new TypeToken<List<AssignStudentResult>>() {
        }.getType());
        tableMap.put("AssessClassRoomLessonTime", new TypeToken<List<AssessClassRoomLessonTime>>() {
        }.getType());
        tableMap.put("AssessStudentLessonTime", new TypeToken<List<AssessStudentLessonTime>>() {
        }.getType());
        tableMap.put("AssessTeacherLessonTime", new TypeToken<List<AssessTeacherLessonTime>>() {
        }.getType());
        tableMap.put("Task", new TypeToken<List<TaskPO>>() {
        }.getType());

    }
    @Resource
    private ClassInfoService classInfoService;
    @Resource
    private CourseService courseService;
    @Resource
    private ClassGroupService classGroupService;
    @Resource
    private ClassGroupClassService classGroupClassService;
    @Resource
    private ClassCourseTeacherService classCourseTeacherService;
    @Resource
    private ClassRoomService classRoomService;
    @Resource
    private ClassRoomCourseService classRoomCourseService;
    @Resource
    private ConditionSettingsService conditionSettingsService;
    @Resource
    private CourseTeacherService courseTeacherService;
    @Resource
    private CoursePlanService coursePlanService;
    @Resource
    private CourseGroupService courseGroupService;
    @Resource
    private CoursePlanChangeHistoryService coursePlanChangeHistoryService;
    @Resource
    private CoursePlanScoreService coursePlanScoreService;
    @Resource
    private ElectiveLessonTimeClassGroupService electiveLessonTimeClassGroupService;
    @Resource
    private ElectiveLessonTimeClassGroupCheckResultService electiveLessonTimeClassGroupCheckResultService;
    @Resource
    private ElectiveLessonTimeClassGroupCoursePlanService electiveLessonTimeClassGroupCoursePlanService;
    @Resource
    private GradeService gradeService;
    @Resource
    private RuleService ruleService;
    @Resource
    private RunningTaskService runningTaskService;
    @Resource
    private ScheduleTimeService scheduleTimeService;
    @Resource
    private StudentService studentService;
    @Resource
    private StudentClassGroupService studentClassGroupService;
    @Resource
    private StudentCourseService studentCourseService;
    @Resource
    private StudentScoreService studentScoreService;
    @Resource
    private SubjectService subjectService;
    @Resource
    private TagInfoService tagInfoService;
    @Resource
    private TagRuleService tagRuleService;
    @Resource
    private TaskQueueService taskQueueService;
    @Resource
    private TaskResultService taskResultService;
    @Resource
    private TaskResultDataService taskResultDataService;
    @Resource
    private TaskRuleService taskRuleService;
    @Resource
    private TaskShareService taskShareService;
    @Resource
    private TeacherService teacherService;
    @Resource
    private AlgorithmParameterService algorithmParameterService;
    @Resource
    private ElectiveAssignStudentClassService electiveAssignStudentClassService;
    @Resource
    private AssessClassRoomLessonTimeService assessClassRoomLessonTimeService;
    @Resource
    private AssessStudentLessonTimeService assessStudentLessonTimeService;
    @Resource
    private AssessTeacherLessonTimeService assessTeacherLessonTimeService;
    @Resource
    private TaskService taskService;

    public TaskService getTaskService() {
        return taskService;
    }

    public void setTaskService(TaskService taskService) {
        this.taskService = taskService;
    }

    public AssessTeacherLessonTimeService getAssessTeacherLessonTimeService() {
        return assessTeacherLessonTimeService;
    }

    public void setAssessTeacherLessonTimeService(AssessTeacherLessonTimeService assessTeacherLessonTimeService) {
        this.assessTeacherLessonTimeService = assessTeacherLessonTimeService;
    }

    public AssessStudentLessonTimeService getAssessStudentLessonTimeService() {
        return assessStudentLessonTimeService;
    }

    public void setAssessStudentLessonTimeService(AssessStudentLessonTimeService assessStudentLessonTimeService) {
        this.assessStudentLessonTimeService = assessStudentLessonTimeService;
    }

    public AssessClassRoomLessonTimeService getAssessClassRoomLessonTimeService() {
        return assessClassRoomLessonTimeService;
    }

    public void setAssessClassRoomLessonTimeService(AssessClassRoomLessonTimeService assessClassRoomLessonTimeService) {
        this.assessClassRoomLessonTimeService = assessClassRoomLessonTimeService;
    }

    public ElectiveAssignStudentClassService getElectiveAssignStudentClassService() {
        return electiveAssignStudentClassService;
    }

    public void setElectiveAssignStudentClassService(ElectiveAssignStudentClassService electiveAssignStudentClassService) {
        this.electiveAssignStudentClassService = electiveAssignStudentClassService;
    }

    public AlgorithmParameterService getAlgorithmParameterService() {
        return algorithmParameterService;
    }

    public void setAlgorithmParameterService(AlgorithmParameterService algorithmParameterService) {
        this.algorithmParameterService = algorithmParameterService;
    }

    public TeacherService getTeacherService() {
        return teacherService;
    }

    public void setTeacherService(TeacherService teacherService) {
        this.teacherService = teacherService;
    }

    public TaskShareService getTaskShareService() {
        return taskShareService;
    }

    public void setTaskShareService(TaskShareService taskShareService) {
        this.taskShareService = taskShareService;
    }

    public TaskRuleService getTaskRuleService() {
        return taskRuleService;
    }

    public void setTaskRuleService(TaskRuleService taskRuleService) {
        this.taskRuleService = taskRuleService;
    }

    public TaskResultDataService getTaskResultDataService() {
        return taskResultDataService;
    }

    public void setTaskResultDataService(TaskResultDataService taskResultDataService) {
        this.taskResultDataService = taskResultDataService;
    }

    public TaskResultService getTaskResultService() {
        return taskResultService;
    }

    public void setTaskResultService(TaskResultService taskResultService) {
        this.taskResultService = taskResultService;
    }

    public TaskQueueService getTaskQueueService() {
        return taskQueueService;
    }

    public void setTaskQueueService(TaskQueueService taskQueueService) {
        this.taskQueueService = taskQueueService;
    }

    public TagRuleService getTagRuleService() {
        return tagRuleService;
    }

    public void setTagRuleService(TagRuleService tagRuleService) {
        this.tagRuleService = tagRuleService;
    }

    public TagInfoService getTagInfoService() {
        return tagInfoService;
    }

    public void setTagInfoService(TagInfoService tagInfoService) {
        this.tagInfoService = tagInfoService;
    }

    public SubjectService getSubjectService() {
        return subjectService;
    }

    public void setSubjectService(SubjectService subjectService) {
        this.subjectService = subjectService;
    }

    public StudentScoreService getStudentScoreService() {
        return studentScoreService;
    }

    public void setStudentScoreService(StudentScoreService studentScoreService) {
        this.studentScoreService = studentScoreService;
    }

    public StudentCourseService getStudentCourseService() {
        return studentCourseService;
    }

    public void setStudentCourseService(StudentCourseService studentCourseService) {
        this.studentCourseService = studentCourseService;
    }

    public StudentClassGroupService getStudentClassGroupService() {
        return studentClassGroupService;
    }

    public void setStudentClassGroupService(StudentClassGroupService studentClassGroupService) {
        this.studentClassGroupService = studentClassGroupService;
    }

    public StudentService getStudentService() {
        return studentService;
    }

    public void setStudentService(StudentService studentService) {
        this.studentService = studentService;
    }

    public ScheduleTimeService getScheduleTimeService() {
        return scheduleTimeService;
    }

    public void setScheduleTimeService(ScheduleTimeService scheduleTimeService) {
        this.scheduleTimeService = scheduleTimeService;
    }

    public RunningTaskService getRunningTaskService() {
        return runningTaskService;
    }

    public void setRunningTaskService(RunningTaskService runningTaskService) {
        this.runningTaskService = runningTaskService;
    }

    public RuleService getRuleService() {
        return ruleService;
    }

    public void setRuleService(RuleService ruleService) {
        this.ruleService = ruleService;
    }

    public GradeService getGradeService() {
        return gradeService;
    }

    public void setGradeService(GradeService gradeService) {
        this.gradeService = gradeService;
    }

    public ElectiveLessonTimeClassGroupCoursePlanService getElectiveLessonTimeClassGroupCoursePlanService() {
        return electiveLessonTimeClassGroupCoursePlanService;
    }

    public void setElectiveLessonTimeClassGroupCoursePlanService(ElectiveLessonTimeClassGroupCoursePlanService electiveLessonTimeClassGroupCoursePlanService) {
        this.electiveLessonTimeClassGroupCoursePlanService = electiveLessonTimeClassGroupCoursePlanService;
    }

    public ElectiveLessonTimeClassGroupCheckResultService getElectiveLessonTimeClassGroupCheckResultService() {
        return electiveLessonTimeClassGroupCheckResultService;
    }

    public void setElectiveLessonTimeClassGroupCheckResultService(ElectiveLessonTimeClassGroupCheckResultService electiveLessonTimeClassGroupCheckResultService) {
        this.electiveLessonTimeClassGroupCheckResultService = electiveLessonTimeClassGroupCheckResultService;
    }

    public ElectiveLessonTimeClassGroupService getElectiveLessonTimeClassGroupService() {
        return electiveLessonTimeClassGroupService;
    }

    public void setElectiveLessonTimeClassGroupService(ElectiveLessonTimeClassGroupService electiveLessonTimeClassGroupService) {
        this.electiveLessonTimeClassGroupService = electiveLessonTimeClassGroupService;
    }

    public MapperFactory() {
    }

    public CoursePlanScoreService getCoursePlanScoreService() {
        return coursePlanScoreService;
    }

    public void setCoursePlanScoreService(CoursePlanScoreService coursePlanScoreService) {
        this.coursePlanScoreService = coursePlanScoreService;
    }

    public CoursePlanChangeHistoryService getCoursePlanChangeHistoryService() {
        return coursePlanChangeHistoryService;
    }

    public void setCoursePlanChangeHistoryService(CoursePlanChangeHistoryService coursePlanChangeHistoryService) {
        this.coursePlanChangeHistoryService = coursePlanChangeHistoryService;
    }

    public CourseTeacherService getCourseTeacherService() {
        return courseTeacherService;
    }

    public void setCourseTeacherService(CourseTeacherService courseTeacherService) {
        this.courseTeacherService = courseTeacherService;
    }

    public CoursePlanService getCoursePlanService() {
        return coursePlanService;
    }

    public void setCoursePlanService(CoursePlanService coursePlanService) {
        this.coursePlanService = coursePlanService;
    }

    public CourseGroupService getCourseGroupService() {
        return courseGroupService;
    }

    public void setCourseGroupService(CourseGroupService courseGroupService) {
        this.courseGroupService = courseGroupService;
    }

    public ConditionSettingsService getConditionSettingsService() {
        return conditionSettingsService;
    }

    public void setConditionSettingsService(ConditionSettingsService conditionSettingsService) {
        this.conditionSettingsService = conditionSettingsService;
    }

    public ClassRoomCourseService getClassRoomCourseService() {
        return classRoomCourseService;
    }

    public void setClassRoomCourseService(ClassRoomCourseService classRoomCourseService) {
        this.classRoomCourseService = classRoomCourseService;
    }

    public ClassRoomService getClassRoomService() {
        return classRoomService;
    }

    public void setClassRoomService(ClassRoomService classRoomService) {
        this.classRoomService = classRoomService;
    }

    public ClassCourseTeacherService getClassCourseTeacherService() {
        return classCourseTeacherService;
    }

    public void setClassCourseTeacherService(ClassCourseTeacherService classCourseTeacherService) {
        this.classCourseTeacherService = classCourseTeacherService;
    }

    public ClassGroupClassService getClassGroupClassService() {
        return classGroupClassService;
    }

    public void setClassGroupClassService(ClassGroupClassService classGroupClassService) {
        this.classGroupClassService = classGroupClassService;
    }

    public ClassGroupService getClassGroupService() {
        return classGroupService;
    }

    public void setClassGroupService(ClassGroupService classGroupService) {
        this.classGroupService = classGroupService;
    }

    public CourseService getCourseService() {
        return courseService;
    }

    public void setCourseService(CourseService courseService) {
        this.courseService = courseService;
    }

    public ClassInfoService getClassInfoService() {
        return classInfoService;
    }

    public void setClassInfoService(ClassInfoService classInfoService) {
        this.classInfoService = classInfoService;
    }

    //这个方法比较通用，只需要注入DAO，加上get方法就行
    //这里是根据表名来拼接一个getter方法名，调用这个get方法获得对应的DAO
    //因为spring管理起来的dao接口都是单例的（只能存在一个）所以只能通过注解注入，
    //通过getter获得，不用new新的对象
    public MethodBase getObject(String tableName, MapperFactory factory) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        String firstLetter = tableName.substring(0, 1).toUpperCase();
        String getter = "get" + firstLetter + tableName.substring(1) + "Service";
        Method method = factory.getClass().getMethod(getter, new Class[]{});
        Object value = method.invoke(factory, new Object[]{});
        return (MethodBase) value;
    }

}

2.上边的类，最关键的就是getObject(String tableName, MapperFactory factory)方法，根据传入的数据库表名和工厂实例，获取可操作该表的接口对象。唯一注意的是，我们写的工厂类里边set，get方法要写的标准一点。在一个就是因为我只用到工厂实例出来的Service对表的查询、删除、插入操作，并且不关心Service的其他方法。所以我的getObject(String tableName, MapperFactory factory)方法统一返回Service都实现的MethodBase接口。

MethodBase接口如下：

import java.util.List;

/**
 * 所有对数据表操作的service实现类都应该实现此接口
 * 接口包括批量插入，查询、删除三个方法
 * @param <T>
 */
public interface MethodBase<T> {

    List<T> selectByTaskIdBak( Long taskId);

    Integer insertBak(List<T> item);

    int deleteByTaskIdBak(long taskId);
}

据其中一个Service的实现例子：

import com.iyunxiao.dora.dao.CommonDao;
import com.iyunxiao.dora.domain.TaskQueue;
import com.iyunxiao.dora.service.MethodBase;
import com.iyunxiao.dora.service.TaskQueueService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author dengjingsi
 * @date $ $
 * @ClassName TaskQueueServiceImpl
 * @Description TODO
 **/
@Service("taskQueueService")
public class TaskQueueServiceImpl extends ServiceBase implements TaskQueueService ,MethodBase<TaskQueue> {
    @Resource
    private CommonDao commonDao;
    @Override
    public List<TaskQueue> selectByTaskIdBak( Long taskId ) {
        return commonDao.selectTaskQueueBak(taskId);
    }

    @Override
    public Integer insertBak( List<TaskQueue> item ) {
        if(item.size()>0){
            return commonDao.insertTaskQueueBak(item);
        }else{
            return 0;
        }
    }

    @Override
    public int deleteByTaskIdBak( long taskId ) {
        return commonDao.deleteTaskQueueBak(taskId);
    }
}

TaskQueueService是该Service需要实现的其他操作方法，可以自行想象。commonDao是操作数据库的dao层，这里就忽略了。

3.下面是我使用工厂类获取静态初始化中，tableMap里边的所有表数据并转化成json进行存储的过程，TaskBackupDetail类是用来存储每个表Json格式的详细数据，有些方法没有那出来，是因为每个人对应的项目具体实现不同，我这里只给大家一个思路。

String tableName;//用于存储临时表名，可以通过表名反射生成操作此表数据的Service对象
TaskBackupDetail taskBackupDetail;//临时的变量
List<TaskBackupDetail> item = new ArrayList<>();
String data;//用于存储Json格式的对象
for(Map.Entry<String,Type> entry:MapperFactory.tableMap.entrySet()){
    tableName = entry.getKey();
    MethodBase base = mapperFactory.getObject(tableName,mapperFactory);//获取操作tableName表的Service
    data = JsonUtils.toJson(base.selectByTaskIdBak(taskId));//把获取到的表数据生产Json对象
    taskBackupDetail = create(taskId, backupId, tableName, data, userId);//根据基本信息生成TaskBackDetail对象
    item.add(taskBackupDetail);
}

还有许多，需要改进的地方，欢迎大家多多提出意见。?