整合sysdictservice到项目里

pom.xml

@@ -17,6 +17,8 @@
 
     <properties>
         <java.version>1.8</java.version>
+        <jwzh.framework.version>2.1.5-SNAPSHOT</jwzh.framework.version>
+        <jwzh.manager-api.version>1.0.33-SNAPSHOT</jwzh.manager-api.version>
     </properties>
 
     <dependencies>
@@ -77,7 +79,63 @@
             <artifactId>commons-net</artifactId>
             <version>3.3</version>
         </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>dom4j</groupId>
+            <artifactId>dom4j</artifactId>
+            <version>1.6.1</version>
+        </dependency>
+        <!--采集生成js文件功能 -->
+        <dependency>
+            <groupId>com.founder</groupId>
+            <artifactId>jwzh-framework-utils</artifactId>
+            <version>${jwzh.framework.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-api</artifactId>
+
+                </exclusion>
+                <exclusion>  <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-log4j12</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.founder</groupId>
+            <artifactId>jwzh-framework-base-server</artifactId>
+            <version>${jwzh.framework.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-api</artifactId>
+
+                </exclusion>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-log4j12</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.founder</groupId>
+            <artifactId>jwzh-manage-api</artifactId>
+            <version>${jwzh.manager-api.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-api</artifactId>
 
+                </exclusion>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-log4j12</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/com/founder/config/DataSourceManagerConfig.java

+package com.founder.config;
+
+import org.apache.ibatis.session.SqlSessionFactory;
+import org.mybatis.spring.SqlSessionFactoryBean;
+import org.mybatis.spring.SqlSessionTemplate;
+import org.mybatis.spring.annotation.MapperScan;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.boot.jdbc.DataSourceBuilder;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
+
+import javax.sql.DataSource;
+
+/**
+ * Created by summer on 2016/11/25.
+ */
+@Configuration
+@MapperScan(basePackages = "com.founder.dictmanager.dao", sqlSessionTemplateRef  = "managerSqlSessionTemplate")
+public class DataSourceManagerConfig {
+
+    @Bean(name = "managerDataSource")
+    @ConfigurationProperties(prefix = "spring.datasource.manager")
+    public DataSource managerDataSource() {
+        return DataSourceBuilder.create().build();
+    }
+
+    @Bean(name = "managerSqlSessionFactory")
+    public SqlSessionFactory managerSqlSessionFactory(@Qualifier("managerDataSource") DataSource dataSource) throws Exception {
+        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
+        bean.setDataSource(dataSource);
+        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/managerMapper/*.xml"));
+        return bean.getObject();
+    }
+    @Bean(name = "managerSqlSessionTemplate")
+    public SqlSessionTemplate managerSqlSessionTemplate(@Qualifier("managerSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
+        return new SqlSessionTemplate(sqlSessionFactory);
+    }
+
+}

src/main/java/com/founder/config/DataSourceXzxtConfig.java

@@ -24,13 +24,11 @@ public class DataSourceXzxtConfig {
 
     @Bean(name = "xzxtDataSource")
     @ConfigurationProperties(prefix = "spring.datasource.xzxt")
-    @Primary
     public DataSource xzxtDataSource() {
         return DataSourceBuilder.create().build();
     }
 
     @Bean(name = "xzxtSqlSessionFactory")
-    @Primary
     public SqlSessionFactory xzxtSqlSessionFactory(@Qualifier("xzxtDataSource") DataSource dataSource) throws Exception {
         SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
         bean.setDataSource(dataSource);
@@ -38,7 +36,6 @@ public class DataSourceXzxtConfig {
         return bean.getObject();
     }
     @Bean(name = "xzxtSqlSessionTemplate")
-    @Primary
     public SqlSessionTemplate xzxtSqlSessionTemplate(@Qualifier("xzxtSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
         return new SqlSessionTemplate(sqlSessionFactory);
     }

src/main/java/com/founder/controller/FaceController.java

@@ -26,7 +26,7 @@ public class FaceController {
     @Autowired
     private FaceService faceService;
     @ResponseBody
-    @RequestMapping("/query")
+    @RequestMapping("/query1")
     public String query() {
         System.out.println("1111111111111111111");
         faceService.sync();;

src/main/java/com/founder/dao/SysXxyyfwGzxxDao.java

+package com.founder.dao;
+
+import com.founder.dictmanager.model.SysXxyyfwGzxx;
+import org.apache.ibatis.annotations.Mapper;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Map;
+
+@Component
+@Mapper
+public interface SysXxyyfwGzxxDao {
+    public String test();
+
+    //public int queryCount(Map<String,Object> param);
+    public List<SysXxyyfwGzxx> queryPageList(Map<String, Object> param);
+
+    int update(SysXxyyfwGzxx sysXxyyfwGzxx);
+
+    int queryUnDealCodeCount();
+}

src/main/java/com/founder/dao/XzxtSysDictDao.java

+package com.founder.dao;
+
+import org.apache.ibatis.annotations.Mapper;
+import org.springframework.stereotype.Component;
+
+@Component
+@Mapper
+public interface XzxtSysDictDao {
+    public String test();
+}

src/main/java/com/founder/dictmanager/controller/SysDictManagerController.java

+package com.founder.dictmanager.controller;
+
+import com.founder.dictmanager.model.GabXfdm;
+import com.founder.dictmanager.service.DictService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import java.util.List;
+
+@Controller
+public class SysDictManagerController {
+
+    @Autowired
+    private DictService sysDictService;
+
+    @RequestMapping("/test")
+    @ResponseBody
+    public void test(){
+        sysDictService.test();
+    }
+
+    @RequestMapping("/updateDict")
+    @ResponseBody
+    public void updateDict(){
+        List<GabXfdm> lists=sysDictService.getGabXfdmRows(1);
+        int r= -1;
+        try {
+            //r = sysDictService.updateManagerDict(lists.get(0));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        System.out.println("更新行数:"+r);
+    }
+
+    @RequestMapping("/updateTestOrgDict")
+    @ResponseBody
+    public void updateOrgDict(){
+        GabXfdm gabXfdm=new GabXfdm();
+        gabXfdm.setBghdm("测试代码");
+        gabXfdm.setBghmc("测试部门");
+        gabXfdm.setSyjdm("测试上级代码");
+        gabXfdm.setSyjmc("测试上级名称");
+
+        gabXfdm.setId("014");
+        gabXfdm.setBghdm("670000000000");
+        gabXfdm.setBglx("1");
+        int r= -1;
+        try {
+            r = sysDictService.updateManagerDict(gabXfdm);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        System.out.println("更新行数:"+r);
+    }
+
+    @RequestMapping("/updateDicts")
+    @ResponseBody
+    public void updateDicts(int rows){
+        if(rows<=0){
+            return;
+        }
+        List<GabXfdm> lists=sysDictService.getGabXfdmRows(rows);
+        int r= -1;
+        try {
+            //r = sysDictService.updateManagerDict(lists.get(0));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        System.out.println("更新行数:"+r);
+    }
+}

src/main/java/com/founder/dictmanager/dao/manager/ManagerSysDictDao.java

+package com.founder.dictmanager.dao.manager;
+
+import com.founder.dictmanager.model.OrganizitionForManager;
+import com.founder.dictmanager.model.SysDictForManager;
+import com.founder.dictmanager.model.SysDictGl;
+import org.apache.ibatis.annotations.Mapper;
+import org.springframework.stereotype.Component;
+
+@Component
+@Mapper
+public interface ManagerSysDictDao {
+    public String test();
+
+    int insertSysDict(SysDictForManager sysDictForManager);
+
+    //int addSysDictGl();
+
+    OrganizitionForManager queryOrganizition(OrganizitionForManager paramOrg);
+
+    int insertOrganizition(OrganizitionForManager organizition);
+
+    int updateOrganizition(OrganizitionForManager organizition);
+
+    int updateSysDict(SysDictForManager sysDictForManager);
+
+    SysDictForManager querySysDict(SysDictForManager paramCode);
+
+    void deleteRepeatDict(SysDictForManager sysDictForManager);
+
+    void deleteRepeatOrgDict(OrganizitionForManager organizition);
+
+    SysDictGl querySysDictGl(SysDictGl paramCode);
+}

src/main/java/com/founder/dictmanager/dao/manager/SysDictDao.java

+package com.founder.dictmanager.dao.manager;
+
+import com.founder.framework.base.entity.SessionBean;
+import com.founder.framework.utils.EasyUIPage;
+import com.founder.dictmanager.model.SysDictForManager;
+import org.apache.ibatis.annotations.Mapper;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+@Mapper
+public interface SysDictDao {
+    List<SysDictForManager> queryListByZdbh(String zdbh);
+
+    EasyUIPage queryList(EasyUIPage page, SysDictForManager entity);
+
+    SysDictForManager query(SysDictForManager entity);
+
+    void update(SysDictForManager entity, SessionBean sessionBean);
+
+    void delete(SysDictForManager entity, SessionBean sessionBean);
+
+    boolean existDm(SysDictForManager entity);
+
+    String getDictCt(String zdbh, String dm);
+
+    String getDictDm(String zdbh, String ct);
+
+    List<SysDictForManager> querListByGlid(Long glid);
+
+    List<SysDictForManager> queryDictForCustomize(String querySql);
+}

src/main/java/com/founder/dictmanager/dao/manager/SysDictGlDao.java

+package com.founder.dictmanager.dao.manager;
+
+import com.founder.dictmanager.model.SysDictGl;
+import org.apache.ibatis.annotations.Mapper;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+@Mapper
+public interface SysDictGlDao {
+    List<SysDictGl> queryAll();
+
+    SysDictGl query(SysDictGl entity);
+}

src/main/java/com/founder/dictmanager/dictionary/api/SysdictServiceApi.java

+package com.founder.dictmanager.dictionary.api;
+
+
+
+import com.founder.dictmanager.dao.manager.SysDictDao;
+import com.founder.dictmanager.dao.manager.SysDictGlDao;
+import com.founder.dictmanager.dictionary.service.DictOtherCreator;
+import com.founder.dictmanager.dictionary.service.DictTreeCreator;
+import com.founder.dictmanager.dictionary.service.SysDictServiceImpl;
+import com.founder.dictmanager.model.SysDictGl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.List;
+
+@Service("SysDictJsFileService")
+public class SysdictServiceApi {
+
+    private static Logger logger = LoggerFactory.getLogger(SysdictServiceApi.class);
+
+    @Value("${jslocation}")
+    private String JSPath;
+    @Autowired
+    private SysDictGlDao sysDictGlDao;
+    @Autowired
+    private SysDictDao sysDictDao;
+    @Autowired
+    private SysDictServiceImpl sysDictService;
+
+    public void checkJSFile() throws Exception {
+        List<SysDictGl> list = this.sysDictGlDao.queryAll();
+        for(int i = 0; i < list.size(); ++i) {
+            SysDictGl entity = list.get(i);
+            String zdywm = entity.getZdywm();
+            if ("GB_D_XZQHDM".equals(zdywm)) {
+                this.createJS(entity);
+            }
+            //this.createJS(entity);
+        }
+
+    }
+
+    public void createJS(SysDictGl entity) throws SQLException, IOException {
+        SysDictGl dbEntity = this.sysDictGlDao.query(entity);
+        String zdsclb = dbEntity.getZdsclb();
+        String zdywm = dbEntity.getZdywm();
+        String zdzwm = dbEntity.getZdzwm();
+
+        try {
+            Class classObject;
+            if ("3".equals(zdsclb)) {
+                classObject = Class.forName("com.founder.dictmanager.dictionary.service.DictOther_" + zdywm);
+                DictOtherCreator creator = (DictOtherCreator)classObject.newInstance();
+                creator.setSysDictDao(this.sysDictDao);
+                creator.setJSPath(JSPath);
+                creator.createOtherJS(zdywm, zdzwm);
+            } else if ("2".equals(zdsclb)) {
+                classObject = Class.forName("com.founder.dictmanager.dictionary.service.DictTree_" + zdywm);
+                DictTreeCreator creator = (DictTreeCreator)classObject.newInstance();
+                creator.setSysDictDao(this.sysDictDao);
+                creator.setJSPath(JSPath);
+                creator.createTreeJS(zdywm, zdzwm);
+            } else {
+                this.sysDictService.createListJS(zdywm, zdzwm);
+            }
+        } catch (Exception var8) {
+            logger.error("生成字典JS文件 ：" + zdywm + ".js 出错: " + var8.getMessage(), var8);
+            System.out.println("文件 ：" + zdywm + ".js 创建失败！");
+        }
+
+    }
+
+}

src/main/java/com/founder/dictmanager/dictionary/controller/SysDictController.java

+package com.founder.dictmanager.dictionary.controller;
+
+import com.founder.framework.exception.BussinessException;
+import com.founder.framework.utils.EasyUIPage;
+import com.founder.dictmanager.dictionary.service.SysDictService;
+import com.founder.dictmanager.model.SysDictForManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.annotation.Resource;
+
+@Controller
+@RequestMapping(value = "sysDict")
+public class SysDictController {
+
+	private Logger logger = LoggerFactory.getLogger(this.getClass());
+
+	@Resource(name = "sysDictService")
+	private SysDictService sysDictService;
+
+	@RequestMapping(value = "/query", method = RequestMethod.GET)
+	public ModelAndView query(SysDictForManager entity) {
+		ModelAndView mv = new ModelAndView("dictionary/sysDict");
+		mv.addObject("entity", entity);
+		return mv;
+	}
+
+	@RequestMapping(value = "/queryCondition", method = RequestMethod.GET)
+	public ModelAndView queryCondition() {
+		ModelAndView mv = new ModelAndView("dictionary/sysDictQueryCondition");
+		return mv;
+	}
+
+	@RequestMapping(value = "/queryList", method = RequestMethod.POST)
+	public @ResponseBody
+	EasyUIPage queryList(EasyUIPage page,
+                         @RequestParam(value = "rows") Integer rows, SysDictForManager entity) {
+		page.setPagePara(rows);
+		return sysDictService.queryList(page, entity);
+	}
+
+	@RequestMapping(value = "/add", method = RequestMethod.GET)
+	public ModelAndView add(SysDictForManager entity) {
+		ModelAndView mv = new ModelAndView("dictionary/sysDictAdd");
+		mv.addObject("entity", entity);
+		return mv;
+	}
+
+	@RequestMapping(value = "/edit", method = RequestMethod.GET)
+	public ModelAndView edit(SysDictForManager entity) throws BussinessException {
+		entity = sysDictService.query(entity);
+		if (entity == null) {
+			throw new BussinessException("该数据不存在或已被注销！");
+		}
+		ModelAndView mv = new ModelAndView("dictionary/sysDictEdit");
+		mv.addObject("entity", entity);
+		return mv;
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/controller/SysDictGlController.java

+package com.founder.dictmanager.dictionary.controller;
+
+import com.alibaba.fastjson.JSON;
+import com.founder.framework.components.AppConst;
+import com.founder.dictmanager.dictionary.api.SysdictServiceApi;
+import com.founder.dictmanager.model.SysDictGl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.annotation.Resource;
+import java.util.HashMap;
+import java.util.Map;
+
+@Controller
+@RequestMapping(value = "sysDictGl")
+public class SysDictGlController {
+
+	private Logger logger = LoggerFactory.getLogger(this.getClass());
+
+	@Resource(name = "SysDictJsFileService")
+	private SysdictServiceApi sysDictGlService;
+
+	@RequestMapping(value = "/query", method = RequestMethod.GET)
+	public ModelAndView query() {
+		ModelAndView mv = new ModelAndView("dictionary/sysDictGl");
+		return mv;
+	}
+
+	@RequestMapping(value = "/queryCondition", method = RequestMethod.GET)
+	public ModelAndView queryCondition() {
+		ModelAndView mv = new ModelAndView("dictionary/sysDictGlQueryCondition");
+		return mv;
+	}
+
+	@RequestMapping(value = "/add", method = RequestMethod.GET)
+	public ModelAndView add() {
+		ModelAndView mv = new ModelAndView("dictionary/sysDictGlAdd");
+		return mv;
+	}
+
+	@RequestMapping(value = "/createJS", method = RequestMethod.POST)
+	public ModelAndView createJS(SysDictGl entity) {
+		ModelAndView mv = new ModelAndView("redirect:/forward/"
+				+ AppConst.FORWORD);
+		Map<String, Object> model = new HashMap<String, Object>();
+		try {
+			if (entity.getId() != null) { // 注销
+				sysDictGlService.createJS(entity);
+				model.put(AppConst.STATUS, AppConst.SUCCESS);
+				model.put(AppConst.MESSAGES, "生成JS文件成功！");
+			}
+		} catch (Exception e) {
+			logger.error(e.getLocalizedMessage(), e);
+			model.put(AppConst.STATUS, AppConst.FAIL);
+			model.put(AppConst.MESSAGES, "生成JS文件成功失败！");
+		}
+		mv.addObject(AppConst.MESSAGES, JSON.toJSON(model));
+		return mv;
+	}
+	
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictOtherCreator.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.dictmanager.dao.manager.SysDictDao;
+import com.founder.dictmanager.model.SysDictForManager;
+import org.springframework.beans.factory.annotation.Value;
+
+import java.util.List;
+import java.util.Map;
+
+public abstract class DictOtherCreator {
+
+	private SysDictDao sysDictDao;
+
+	public String getJSPath() {
+		return JSPath;
+	}
+
+	public void setJSPath(String JSPath) {
+		this.JSPath = JSPath;
+	}
+	@Value("${JSPath}")
+	protected  String JSPath;
+
+	public void setSysDictDao(SysDictDao sysDictDao) {
+		this.sysDictDao = sysDictDao;
+	}
+
+	public SysDictDao getSysDictDao() {
+		return sysDictDao;
+	}
+
+	/**
+	 * 创建其他字典JS文件<br>
+	 * 
+	 * @param zdbh
+	 *            字典类别
+	 * @param zdbhMc
+	 *            字典名称
+	 * @throws Exception void
+	 */
+	public abstract void createOtherJS(String zdbh, String zdbhMc)
+			throws Exception;
+
+	/**
+	 * 根据代码取得其他字典的词条<br>
+	 * 
+	 * @param zdbh
+	 * @param dm
+	 * @return
+	 * @throws Exception
+	 *             String
+	 */
+	public abstract String getDictCt(String zdbh, String dm) throws Exception;
+
+	/**
+	 * 获得字典的列表<br>
+	 * 
+	 * @param zdbh
+	 * @return List
+	 */
+	public abstract List<SysDictForManager> getDictList(String zdbh);
+
+	/**
+	 * 获得字典的集合<br>
+	 * 
+	 * @param zdbh
+	 * @return HashMap
+	 */
+	public abstract Map<String, String> getDictMap(String zdbh);
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTreeCreator.java

+package com.founder.dictmanager.dictionary.service;
+
+
+import com.founder.dictmanager.dao.manager.SysDictDao;
+import org.springframework.beans.factory.annotation.Value;
+
+public abstract class DictTreeCreator {
+
+	private SysDictDao sysDictDao;
+
+	@Value("${JSPath}")
+	protected String JSPath;
+
+	public String getJSPath() {
+		return JSPath;
+	}
+
+	public void setJSPath(String JSPath) {
+		this.JSPath = JSPath;
+	}
+
+	public void setSysDictDao(SysDictDao sysDictDao) {
+		this.sysDictDao = sysDictDao;
+	}
+
+	public SysDictDao getSysDictDao() {
+		return sysDictDao;
+	}
+
+	/**
+	 * 创建树形字典JS文件<br>
+	 * 
+	 * @param zdbh
+	 *            字典类别
+	 * @param zdbhMc
+	 *            字典名称
+	 * @throws Exception void
+	 */
+	public abstract void createTreeJS(String zdbh, String zdbhMc)
+			throws Exception;
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_BD_D_CLLX.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_BD_D_CLLX extends DictTreeCreator {
+
+	private String treeName = "车辆类型";
+
+	public DictTree_BD_D_CLLX() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py,wb, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.length()==1) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						continue;
+					}
+					py = dictList.get(i1).getPy();
+					wb = dictList.get(i1).getWb();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					treeNode1.setWb(wb);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1; // 下一级前1位 是上一级代码
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								continue;
+							}
+							py = dictList.get(i2).getPy();
+							wb = dictList.get(i2).getWb();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							treeNode2.setWb(wb);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_BD_D_DWFLDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_BD_D_DWFLDM extends DictTreeCreator {
+
+	private String treeName = "单位分类代码";
+
+	public DictTree_BD_D_DWFLDM() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py,wb, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("0000")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					wb = dictList.get(i1).getWb();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					treeNode1.setWb(wb);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)
+								&&(dm2.endsWith("00") || dm2.endsWith("20"))){ // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							wb = dictList.get(i2).getWb();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							treeNode2.setWb(wb);
+							// 获取第3级结点开始
+							List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+							String dm2Matching = dm2.substring(0, 3); // 下一级为前3位相同
+							for (int i3 = 0; i3 < dictList.size(); i3++) {
+								String dm3 = dictList.get(i3).getDm();
+								dm3 = StringUtils.nullToStr(dm3);
+								if (!dm3.equals(dm2)
+										&& dm3.startsWith(dm2Matching) && !dm2.equals("10020")) { // 第3级判断条件
+									TreeNode treeNode3 = new TreeNode();
+									mc = dictList.get(i3).getCt();
+									xt_zxbz = StringUtils.nullToStr(dictList
+											.get(i3).getXtZxbz());
+									if ("1".equals(xt_zxbz)) {
+										mc += "（已注销）";
+									}
+									py = dictList.get(i3).getPy();
+									wb = dictList.get(i2).getWb();
+									treeNode3.setId(dm3);
+									treeNode3.setText(mc);
+									treeNode3.setPy(py);
+									treeNode2.setWb(wb);
+									nodeList3.add(treeNode3);
+								}
+							}
+							if (nodeList3.size() > 0) {
+								treeNode2.setState("closed");
+								treeNode2.setChildren(nodeList3);
+							}
+							// 获取第3级结点结束
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_BD_D_GXDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.PathUtil;
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_BD_D_GXDM extends DictTreeCreator {
+
+	private String treeName = "人员关系代码";
+
+	public DictTree_BD_D_GXDM() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		String JSPath = PathUtil.getServlet_context_path() + "/common/dict/";
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py,wb, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.length()==1) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					wb = dictList.get(i1).getWb();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					treeNode1.setWb(wb);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							wb = dictList.get(i2).getWb();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							treeNode2.setWb(wb);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_BD_D_JQLBDM.java

+package com.founder.dictmanager.dictionary.service;
+
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_BD_D_JQLBDM  extends DictTreeCreator {
+
+	private String treeName ="警情类别代码";
+	
+	public DictTree_BD_D_JQLBDM(){
+		
+	}
+	
+	
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+
+		if (dictList != null && dictList.size() > 0) { // 有数据			
+			String  mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();			
+		   for(int i1 = 0; i1 < dictList.size(); i1++){
+			    String dm1 = dictList.get(i1).getDm();
+							   
+				if(dm1.length()!=0 && dm1.length()<=2){//第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					//获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();	
+					 String  dm1Matching=dm1;
+					  for (int i2 = 0; i2 < dictList.size(); i2++) {
+						    String dm2 = dictList.get(i2).getDm();
+							dm2 = StringUtils.nullToStr(dm2); 
+					
+					 if(dm2.startsWith(dm1Matching) && dm2.length()-dm1.length()==2){//第二级判定条件							  
+						   TreeNode treeNode2 = new TreeNode();
+						    mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+					// 获取第3级结点开始
+					List<TreeNode> nodeList3 = new ArrayList<TreeNode>();	
+							 String  dm2Matching=dm2;
+					for(int i3 = 0; i3 < dictList.size(); i3++){
+						String dm3 = dictList.get(i3).getDm();
+						dm3 = StringUtils.nullToStr(dm3); 
+				   
+					  if(dm3.startsWith(dm2Matching) && dm3.length()-dm2.length()==2){//第三极判定条件
+				    	
+						  TreeNode treeNode3 = new TreeNode();
+						    mc = dictList.get(i3).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i3)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i3).getPy();
+							treeNode3.setId(dm3);
+							treeNode3.setText(mc);
+							treeNode3.setPy(py); 
+					// 获取第4级结点开始
+					List<TreeNode> nodeList4 = new ArrayList<TreeNode>();	
+							 String  dm3Matching=dm3;	
+							 for(int i4 = 0; i4 < dictList.size(); i4++){
+									String dm4 = dictList.get(i4).getDm();
+									dm4 = StringUtils.nullToStr(dm4);
+							   
+					  if(dm4.startsWith(dm3Matching) && dm4.length()-dm3.length()==2){//第三极判定条件
+				    	
+						  TreeNode treeNode4 = new TreeNode();
+						    mc = dictList.get(i4).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i4)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i4).getPy();
+							treeNode4.setId(dm4);
+							treeNode4.setText(mc);
+							treeNode4.setPy(py);
+							nodeList4.add(treeNode4);
+					      }
+					  }
+					     if (nodeList4.size() > 0) {
+							treeNode3.setState("closed");
+							treeNode3.setChildren(nodeList4);
+						   }
+						// 获取第4级结点结束
+				        nodeList3.add(treeNode3);	 
+					     }
+					  }
+				     if (nodeList3.size() > 0) {
+						treeNode2.setState("closed");
+						treeNode2.setChildren(nodeList3);
+					   }
+					// 获取第3级结点结束
+			        nodeList2.add(treeNode2);	
+					   }
+					  }
+				     if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					   }
+					// 获取第2级结点结束
+			        nodeList1.add(treeNode1);      
+				   }
+		         }				
+						
+		   String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}
+	
+	
+
+
+

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_BD_D_PFYWLXDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_BD_D_PFYWLXDM extends DictTreeCreator {
+
+	private String treeName = "批复业务类型";
+
+	public DictTree_BD_D_PFYWLXDM() {
+	}
+
+	public boolean isAutoCreateJS() {
+		return false;
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.length() == 2) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 2); // 下一级为前2位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)
+								&& dm2.length() == 4) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							// 获取第3级结点开始
+							List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+							String dm2Matching = dm2.substring(0, 4); // 下一级为前4位相同
+							for (int i3 = 0; i3 < dictList.size(); i3++) {
+								String dm3 = dictList.get(i3).getDm();
+								dm3 = StringUtils.nullToStr(dm3);
+								if (!dm3.equals(dm2)
+										&& dm3.startsWith(dm2Matching)) { // 第3级判断条件
+									TreeNode treeNode3 = new TreeNode();
+									mc = dictList.get(i3).getCt();
+									xt_zxbz = StringUtils.nullToStr(dictList
+											.get(i3).getXtZxbz());
+									if ("1".equals(xt_zxbz)) {
+										mc += "（已注销）";
+									}
+									py = dictList.get(i3).getPy();
+									treeNode3.setId(dm3);
+									treeNode3.setText(mc);
+									treeNode3.setPy(py);
+									nodeList3.add(treeNode3);
+								}
+							}
+							if (nodeList3.size() > 0) {
+								treeNode2.setState("closed");
+								treeNode2.setChildren(nodeList3);
+							}
+							// 获取第3级结点结束
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_BD_D_SYRKYWLXDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_BD_D_SYRKYWLXDM extends DictTreeCreator {
+
+	private String treeName = "人员属性";
+
+	public DictTree_BD_D_SYRKYWLXDM() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py,wb, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.length()==1) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					wb = dictList.get(i1).getWb();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					treeNode1.setWb(wb);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1; // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							wb = dictList.get(i2).getWb();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							treeNode2.setWb(wb);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_BD_D_WPLBDM.java

+package com.founder.dictmanager.dictionary.service;
+
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_BD_D_WPLBDM extends DictTreeCreator {
+
+    private String treeName ="物品类别代码";
+
+    public DictTree_BD_D_WPLBDM(){
+
+    }
+
+
+    public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+
+        List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+
+        if (dictList != null && dictList.size() > 0) { // 有数据
+            String  mc, py, xt_zxbz;
+            List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+            for(int i1 = 0; i1 < dictList.size(); i1++){
+                String dm1 = dictList.get(i1).getDm();
+
+                if(dm1.length()!=0 && dm1.length()==1){//第1级判断条件
+                    TreeNode treeNode1 = new TreeNode();
+                    mc = dictList.get(i1).getCt();
+                    xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+                            .getXtZxbz());
+                    if ("1".equals(xt_zxbz)) {
+                        mc += "（已注销）";
+                    }
+                    py = dictList.get(i1).getPy();
+                    treeNode1.setId(dm1);
+                    treeNode1.setText(mc);
+                    treeNode1.setPy(py);
+                    //获取第2级结点开始
+                    List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+                    String  dm1Matching=dm1;
+                    for (int i2 = 0; i2 < dictList.size(); i2++) {
+                        String dm2 = dictList.get(i2).getDm();
+                        dm2 = StringUtils.nullToStr(dm2);
+
+                        if(dm1.equals(getParentDm(dm2))){//第二级判定条件
+                            TreeNode treeNode2 = new TreeNode();
+                            mc = dictList.get(i2).getCt();
+                            xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+                                    .getXtZxbz());
+                            if ("1".equals(xt_zxbz)) {
+                                mc += "（已注销）";
+                            }
+                            py = dictList.get(i2).getPy();
+                            treeNode2.setId(dm2);
+                            treeNode2.setText(mc);
+                            treeNode2.setPy(py);
+                            // 获取第3级结点开始
+                            List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+                            String  dm2Matching=dm2;
+                            for(int i3 = 0; i3 < dictList.size(); i3++){
+                                String dm3 = dictList.get(i3).getDm();
+                                dm3 = StringUtils.nullToStr(dm3);
+
+                                if(dm2.equals(getParentDm(dm3))){//第三极判定条件
+
+                                    TreeNode treeNode3 = new TreeNode();
+                                    mc = dictList.get(i3).getCt();
+                                    xt_zxbz = StringUtils.nullToStr(dictList.get(i3)
+                                            .getXtZxbz());
+                                    if ("1".equals(xt_zxbz)) {
+                                        mc += "（已注销）";
+                                    }
+                                    py = dictList.get(i3).getPy();
+                                    treeNode3.setId(dm3);
+                                    treeNode3.setText(mc);
+                                    treeNode3.setPy(py);
+                                    // 获取第4级结点开始
+                                    List<TreeNode> nodeList4 = new ArrayList<TreeNode>();
+                                    String  dm3Matching=dm3;
+                                    for(int i4 = 0; i4 < dictList.size(); i4++){
+                                        String dm4 = dictList.get(i4).getDm();
+                                        dm4 = StringUtils.nullToStr(dm4);
+
+                                        if(dm3.equals(getParentDm(dm4))){//第四极判定条件
+
+                                            TreeNode treeNode4 = new TreeNode();
+                                            mc = dictList.get(i4).getCt();
+                                            xt_zxbz = StringUtils.nullToStr(dictList.get(i4)
+                                                    .getXtZxbz());
+                                            if ("1".equals(xt_zxbz)) {
+                                                mc += "（已注销）";
+                                            }
+                                            py = dictList.get(i4).getPy();
+                                            treeNode4.setId(dm4);
+                                            treeNode4.setText(mc);
+                                            treeNode4.setPy(py);
+                                            nodeList4.add(treeNode4);
+                                        }
+                                    }
+                                    if (nodeList4.size() > 0) {
+                                        treeNode3.setState("closed");
+                                        treeNode3.setChildren(nodeList4);
+                                    }
+                                    // 获取第4级结点结束
+                                    nodeList3.add(treeNode3);
+                                }
+                            }
+                            if (nodeList3.size() > 0) {
+                                treeNode2.setState("closed");
+                                treeNode2.setChildren(nodeList3);
+                            }
+                            // 获取第3级结点结束
+                            nodeList2.add(treeNode2);
+                        }
+                    }
+                    if (nodeList2.size() > 0) {
+                        treeNode1.setState("closed");
+                        treeNode1.setChildren(nodeList2);
+                    }
+                    // 获取第2级结点结束
+                    nodeList1.add(treeNode1);
+                }
+            }
+
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+                    + "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+                    + StringUtils.enterNewline + StringUtils.enterNewline);
+            fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+            fileWriter.write(StringUtils.enterNewline + "}]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        } else {
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        }
+    }
+
+
+
+    public static String getParentDm(String dm) {
+        if (StringUtils.isBlank(dm)) {
+            return "";
+        }
+        if (dm.length() <= 1) {
+            //长度小于或者等于1 已经是最上级
+            return "";
+        }
+        String parentDm =null;
+
+        if(dm.length() == 2){
+            parentDm = dm.substring(0,1);
+        }
+        if(dm.length() == 3){
+            parentDm = dm.substring(0,2);
+        }
+        if(dm.length() == 4){
+            parentDm = dm.substring(0,1);
+        }
+        if(dm.length() != 1 && dm.startsWith("X")){
+            parentDm ="X";
+        }
+        if(dm.length() == 5 && dm.endsWith("00") && !dm.startsWith("X")){
+            parentDm =dm.substring(0,1);
+        }
+        if(dm.length() == 5 && !dm.endsWith("00") && !dm.startsWith("X")&&(!dm.startsWith("B")&&!dm.startsWith("E")&&!dm.startsWith("V"))){
+            parentDm =dm.substring(0,3)+"00";
+        }
+
+        if(dm.length() == 5 &&!dm.endsWith("00") && dm.endsWith("0") && !dm.startsWith("X") && (dm.startsWith("B")||dm.startsWith("E")||dm.startsWith("V"))){
+            parentDm =dm.substring(0,3)+"00";
+        }
+        if(dm.length() == 5 &&!dm.endsWith("00") &&!dm.endsWith("0") && !dm.startsWith("X") && (dm.startsWith("B")||dm.startsWith("E")||dm.startsWith("V"))){
+            parentDm =dm.substring(0,4)+"0";
+        }
+
+        if(dm.length() == 5 && (dm.startsWith("1")||dm.startsWith("2")||dm.startsWith("3")||dm.startsWith("4"))){
+            if(dm.endsWith("0000")){
+                parentDm = "0";
+            }
+            if(dm.endsWith("00")){
+                parentDm =dm.substring(0,1)+"0000";
+            }
+            if(!dm.endsWith("00")){
+                parentDm =dm.substring(0,3)+"00";
+            }
+        }
+        return  parentDm;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(getParentDm("C0230"));
+    }
+
+
+}
+	
+	
+
+
+

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_BD_D_WPMC.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_BD_D_WPMC extends DictTreeCreator {
+
+    private String treeName = "刑事案件类别代码";
+
+
+    public DictTree_BD_D_WPMC() {
+
+
+    }
+
+
+    public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+        List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+        if (dictList != null && dictList.size() > 0) { // 有数据
+            String mc, py, xt_zxbz;
+            List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+
+            for (int i1 = 0; i1 < dictList.size(); i1++) {
+                String dm1 = dictList.get(i1).getDm();
+                dm1 = StringUtils.nullToStr(dm1);
+                if (dm1.endsWith("0000") || dm1.length() == 1) {//第一级判定条件
+                    TreeNode treeNode1 = new TreeNode();
+                    mc = dictList.get(i1).getCt();
+                    xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+                            .getXtZxbz());
+                    if ("1".equals(xt_zxbz)) {
+                        continue;
+                    }
+                    py = dictList.get(i1).getPy();
+                    treeNode1.setId(dm1);
+                    treeNode1.setText(mc);
+                    treeNode1.setPy(py);
+
+                    // 获取第2级结点开始
+                    List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+                    for (int i2 = 0; i2 < dictList.size(); i2++) {
+                        String dm2 = dictList.get(i2).getDm();
+                        dm2 = StringUtils.nullToStr(dm2);
+                        if (dm1.equals(getParentDm(dm2))) {//第二级判定条件
+                            TreeNode treeNode2 = new TreeNode();
+
+                            mc = dictList.get(i2).getCt();
+                            xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+                                    .getXtZxbz());
+                            if ("1".equals(xt_zxbz)) {
+                                mc += "（已注销）";
+                            }
+                            py = dictList.get(i2).getPy();
+                            treeNode2.setId(dm2);
+                            treeNode2.setText(mc);
+                            treeNode2.setPy(py);
+
+                            // 获取第3级结点开始
+                            List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+                            for (int i3 = 0; i3 < dictList.size(); i3++) {
+                                String dm3 = dictList.get(i3).getDm();
+                                dm3 = StringUtils.nullToStr(dm3);
+                                if (dm2.equals(getParentDm(dm3))) {//第三级判定条件
+                                    TreeNode treeNode3 = new TreeNode();
+                                    mc = dictList.get(i3).getCt();
+                                    xt_zxbz = StringUtils.nullToStr(dictList
+                                            .get(i3).getXtZxbz());
+                                    if ("1".equals(xt_zxbz)) {
+                                        mc += "（已注销）";
+                                    }
+                                    py = dictList.get(i3).getPy();
+                                    treeNode3.setId(dm3);
+                                    treeNode3.setText(mc);
+                                    treeNode3.setPy(py);
+                                    nodeList3.add(treeNode3);
+                                }
+                            }
+                            if (nodeList3.size() > 0) {
+                                treeNode2.setState("closed");
+                                treeNode2.setChildren(nodeList3);
+                            }
+                            // 获取第3级结点结束
+                            nodeList2.add(treeNode2);
+                        }
+                    }
+                    if (nodeList2.size() > 0) {
+                        treeNode1.setState("closed");
+                        treeNode1.setChildren(nodeList2);
+                    }
+                    // 获取第2级结点结束
+                    nodeList1.add(treeNode1);
+                }
+            }
+
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+                    + "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+                    + StringUtils.enterNewline + StringUtils.enterNewline);
+            fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+            fileWriter.write(StringUtils.enterNewline + "}]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        } else {
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        }
+    }
+
+
+    public static String getParentDm(String dm) {
+        if (StringUtils.isBlank(dm) || dm.length() == 1) {
+            return "";
+        }
+        if (dm.length() > 1 && "WXY".indexOf(dm.substring(0, 1)) > -1) {
+            //这三种 只有两级 父级为首字母
+            return dm.substring(0, 1);
+        }
+        if (dm.length() > 1 && "Z".indexOf(dm.substring(0, 1)) > -1) {
+            //每级只有一个数字表示
+            return dm.substring(0, dm.length() - 1);
+        }
+        StringBuilder childDm = new StringBuilder(dm);
+
+        while (childDm.length() > 2 && "00".equals(childDm.substring(childDm.length() - 2))) {
+            childDm.delete(childDm.length() - 2, childDm.length());
+        }
+        if (childDm.length() <= 2) {
+            //长度小于或者等于2 已经是最上级
+            return "";
+        }
+        childDm.delete(childDm.length() - 2, childDm.length());
+        String num = "1234";
+        String parentStr = num.lastIndexOf(dm.substring(0, 1)) < 0 ? dm.substring(0, 1) : childDm.toString() + String.format("%1$0" + (5 - childDm.length()) + "d", 0);
+        return parentStr;
+
+
+    }
+
+    public static void main(String[] args) {
+        System.out.println(getParentDm("10000"));
+    }
+
+}
+
+

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_GJDQ.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_GJDQ extends DictTreeCreator {
+
+	private String treeName = "国家和地区";
+
+	public DictTree_D_BZ_GJDQ() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		String tableNameUpper = zdbh.toUpperCase();
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String dm, mc, py, xt_zxbz;
+
+			StringBuffer sb = new StringBuffer();
+			sb.append("[" + StringUtils.enterNewline);
+			long countAdd = 0;
+			long count = dictList.size();
+			for (int i = 0; i < dictList.size(); i++) {
+				SysDictForManager entity = dictList.get(i);
+				countAdd++;
+				dm = entity.getDm();
+				mc = entity.getCt();
+				py = entity.getPy();
+				xt_zxbz = entity.getXtZxbz();
+				if ("1".equals(xt_zxbz)) {
+					mc += "（已注销）";
+				}
+				String optionString = "\"id\":\"" + dm + "\",\"text\":\"" + mc
+						+ "\",\"py\":\"" + py + "\"";
+				sb.append("{" + optionString + "}");
+				if (countAdd < count) {
+					sb.append(",");
+				}
+				sb.append(StringUtils.enterNewline);
+			}
+			sb.append("]" + StringUtils.enterNewline);
+			Writer fileWriterList1 = new OutputStreamWriter(
+					new FileOutputStream(JSPath + tableNameUpper + "LIST.js"),
+					"UTF8");
+			fileWriterList1.write(sb.toString());
+			fileWriterList1.flush();
+			fileWriterList1.close();
+			System.out.println("文件 ：" + tableNameUpper + "LIST.js 创建成功！");
+
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				TreeNode treeNode1 = new TreeNode();
+				mc = dictList.get(i1).getCt();
+				xt_zxbz = StringUtils.nullToStr(dictList.get(i1).getXtZxbz());
+				if ("1".equals(xt_zxbz)) {
+					mc += "（已注销）";
+				}
+				py = dictList.get(i1).getPy();
+				treeNode1.setId(dm1);
+				treeNode1.setText(mc);
+				treeNode1.setPy(py);
+				nodeList1.add(treeNode1);
+			}
+			Writer fileWriter2 = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter2.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter2.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter2.write(StringUtils.enterNewline + "}]");
+			fileWriter2.flush();
+			fileWriter2.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			Writer fileWriterList1 = new OutputStreamWriter(
+					new FileOutputStream(JSPath + tableNameUpper + "LIST.js"),
+					"UTF8");
+			fileWriterList1.write("[]");
+			fileWriterList1.flush();
+			fileWriterList1.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + "LIST.js 创建成功！");
+
+			Writer fileWriter2 = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter2.write("[]");
+			fileWriter2.flush();
+			fileWriter2.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_RYGX.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_RYGX extends DictTreeCreator {
+
+	private String treeName = "人员关系"; // 字典名称
+
+	public DictTree_D_BZ_RYGX() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("00")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)
+								&& dm2.endsWith("0")) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							// 获取第3级结点开始
+							List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+							String dm2Matching = dm2.substring(0, 2); // 下一级为前2位相同
+							for (int i3 = 0; i3 < dictList.size(); i3++) {
+								String dm3 = dictList.get(i3).getDm();
+								dm3 = StringUtils.nullToStr(dm3);
+								if (!dm3.equals(dm2)
+										&& dm3.startsWith(dm2Matching)) { // 第3级判断条件
+									TreeNode treeNode3 = new TreeNode();
+									mc = dictList.get(i3).getCt();
+									xt_zxbz = StringUtils.nullToStr(dictList
+											.get(i3).getXtZxbz());
+									if ("1".equals(xt_zxbz)) {
+										mc += "（已注销）";
+									}
+									py = dictList.get(i3).getPy();
+									treeNode3.setId(dm3);
+									treeNode3.setText(mc);
+									treeNode3.setPy(py);
+									nodeList3.add(treeNode3);
+								}
+							}
+							if (nodeList3.size() > 0) {
+								treeNode2.setState("closed");
+								treeNode2.setChildren(nodeList3);
+							}
+							// 获取第3级结点结束
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_TBBJ.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_TBBJ extends DictTreeCreator {
+
+	private String treeName = "体表标记";
+
+	public DictTree_D_BZ_TBBJ() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("00")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)
+								&& dm2.endsWith("0")) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							// 获取第3级结点开始
+							List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+							String dm2Matching = dm2.substring(0, 2); // 下一级为前2位相同
+							for (int i3 = 0; i3 < dictList.size(); i3++) {
+								String dm3 = dictList.get(i3).getDm();
+								dm3 = StringUtils.nullToStr(dm3);
+								if (!dm3.equals(dm2)
+										&& dm3.startsWith(dm2Matching)) { // 第3级判断条件
+									TreeNode treeNode3 = new TreeNode();
+									mc = dictList.get(i3).getCt();
+									xt_zxbz = StringUtils.nullToStr(dictList
+											.get(i3).getXtZxbz());
+									if ("1".equals(xt_zxbz)) {
+										mc += "（已注销）";
+									}
+									py = dictList.get(i3).getPy();
+									treeNode3.setId(dm3);
+									treeNode3.setText(mc);
+									treeNode3.setPy(py);
+									nodeList3.add(treeNode3);
+								}
+							}
+							if (nodeList3.size() > 0) {
+								treeNode2.setState("closed");
+								treeNode2.setChildren(nodeList3);
+							}
+							// 获取第3级结点结束
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_WHCD.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_WHCD extends DictTreeCreator {
+
+	private String treeName = "文化程度";
+
+	public DictTree_D_BZ_WHCD() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("0")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_XZCS.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_XZCS extends DictTreeCreator {
+
+	private String treeName = "选择处所";
+
+	public DictTree_D_BZ_XZCS() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("00")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 2); // 下一级为前2位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_XZDXDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_XZDXDM extends DictTreeCreator {
+
+	private String treeName = "选择对象";
+
+	public DictTree_D_BZ_XZDXDM() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("00")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_XZFS.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_XZFS extends DictTreeCreator {
+
+	private String treeName = "销赃方式";
+
+	public DictTree_D_BZ_XZFS() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("00") || "999".equals(dm1)) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_XZFSFLHDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_XZFSFLHDM extends DictTreeCreator {
+
+	private String treeName = "销赃方式分类和代码";
+
+	public DictTree_D_BZ_XZFSFLHDM() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("00") || "999".equals(dm1)) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_ZASD.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_ZASD extends DictTreeCreator {
+
+	private String treeName = "作案手段";
+
+	public DictTree_D_BZ_ZASD() {
+	}
+
+	public boolean isAutoCreateJS() {
+		return false;
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("000")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)
+								&& dm2.endsWith("00")) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							// 获取第3级结点开始
+							List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+							String dm2Matching = dm2.substring(0, 2); // 下一级为前2位相同
+							for (int i3 = 0; i3 < dictList.size(); i3++) {
+								String dm3 = dictList.get(i3).getDm();
+								dm3 = StringUtils.nullToStr(dm3);
+								if (!dm3.equals(dm2)
+										&& dm3.startsWith(dm2Matching)) { // 第3级判断条件
+									TreeNode treeNode3 = new TreeNode();
+									mc = dictList.get(i3).getCt();
+									xt_zxbz = StringUtils.nullToStr(dictList
+											.get(i3).getXtZxbz());
+									if ("1".equals(xt_zxbz)) {
+										mc += "（已注销）";
+									}
+									py = dictList.get(i3).getPy();
+									treeNode3.setId(dm3);
+									treeNode3.setText(mc);
+									treeNode3.setPy(py);
+									nodeList3.add(treeNode3);
+								}
+							}
+							if (nodeList3.size() > 0) {
+								treeNode2.setState("closed");
+								treeNode2.setChildren(nodeList3);
+							}
+							// 获取第3级结点结束
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_ZYFLYDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_ZYFLYDM extends DictTreeCreator {
+
+	private String treeName = "职业类别代码";
+
+	public DictTree_D_BZ_ZYFLYDM() {
+	}
+
+	public boolean isAutoCreateJS() {
+		return false;
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("00")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)
+								&& dm2.endsWith("0")) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							// 获取第3级结点开始
+							List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+							String dm2Matching = dm2.substring(0, 2); // 下一级为前2位相同
+							for (int i3 = 0; i3 < dictList.size(); i3++) {
+								String dm3 = dictList.get(i3).getDm();
+								dm3 = StringUtils.nullToStr(dm3);
+								if (!dm3.equals(dm2)
+										&& dm3.startsWith(dm2Matching)) { // 第3级判断条件
+									TreeNode treeNode3 = new TreeNode();
+									mc = dictList.get(i3).getCt();
+									xt_zxbz = StringUtils.nullToStr(dictList
+											.get(i3).getXtZxbz());
+									if ("1".equals(xt_zxbz)) {
+										mc += "（已注销）";
+									}
+									py = dictList.get(i3).getPy();
+									treeNode3.setId(dm3);
+									treeNode3.setText(mc);
+									treeNode3.setPy(py);
+									nodeList3.add(treeNode3);
+								}
+							}
+							if (nodeList3.size() > 0) {
+								treeNode2.setState("closed");
+								treeNode2.setChildren(nodeList3);
+							}
+							// 获取第3级结点结束
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_BZ_ZYLB.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_BZ_ZYLB extends DictTreeCreator {
+
+	private String treeName = "职业类别";
+
+	public DictTree_D_BZ_ZYLB() {
+	}
+
+	public boolean isAutoCreateJS() {
+		return false;
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("00")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)
+								&& dm2.endsWith("0")) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							// 获取第3级结点开始
+							List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+							String dm2Matching = dm2.substring(0, 2); // 下一级为前2位相同
+							for (int i3 = 0; i3 < dictList.size(); i3++) {
+								String dm3 = dictList.get(i3).getDm();
+								dm3 = StringUtils.nullToStr(dm3);
+								if (!dm3.equals(dm2)
+										&& dm3.startsWith(dm2Matching)) { // 第3级判断条件
+									TreeNode treeNode3 = new TreeNode();
+									mc = dictList.get(i3).getCt();
+									xt_zxbz = StringUtils.nullToStr(dictList
+											.get(i3).getXtZxbz());
+									if ("1".equals(xt_zxbz)) {
+										mc += "（已注销）";
+									}
+									py = dictList.get(i3).getPy();
+									treeNode3.setId(dm3);
+									treeNode3.setText(mc);
+									treeNode3.setPy(py);
+									nodeList3.add(treeNode3);
+								}
+							}
+							if (nodeList3.size() > 0) {
+								treeNode2.setState("closed");
+								treeNode2.setChildren(nodeList3);
+							}
+							// 获取第3级结点结束
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_RK_CLLX.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_RK_CLLX extends DictTreeCreator {
+
+	private String treeName = "车辆类型";
+
+	public DictTree_D_RK_CLLX() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.length() == 1) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_RK_JTGX.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_RK_JTGX extends DictTreeCreator {
+
+	private String treeName = "家庭关系";
+
+	public DictTree_D_RK_JTGX() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.startsWith("0") || dm1.endsWith("0")
+						&& !"90".equals(dm1)) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if ("8".equals(dm1Matching) && dm2.startsWith("9")) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							nodeList2.add(treeNode2);
+						} else {
+							if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)
+									&& !dm1.startsWith("0")) { // 第2级判断条件
+								TreeNode treeNode2 = new TreeNode();
+								mc = dictList.get(i2).getCt();
+								xt_zxbz = StringUtils.nullToStr(dictList
+										.get(i2).getXtZxbz());
+								if ("1".equals(xt_zxbz)) {
+									mc += "（已注销）";
+								}
+								py = dictList.get(i2).getPy();
+								treeNode2.setId(dm2);
+								treeNode2.setText(mc);
+								treeNode2.setPy(py);
+								nodeList2.add(treeNode2);
+							}
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_RK_JWRYSFDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_RK_JWRYSFDM extends DictTreeCreator {
+
+	private String treeName = "境外人员身份";
+
+	public DictTree_D_RK_JWRYSFDM() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("0") || "99".equals(dm1)) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_RK_WHSHHGDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_RK_WHSHHGDM extends DictTreeCreator {
+
+	private String treeName = "危害社会、身体、家庭后果代码";
+
+	public DictTree_D_RK_WHSHHGDM() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("00")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 1); // 下一级为前1位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_D_RK_ZDRYLB.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_D_RK_ZDRYLB extends DictTreeCreator {
+
+	private String treeName = "重点人员类别";
+
+	public DictTree_D_RK_ZDRYLB() {
+	}
+
+	public boolean isAutoCreateJS() {
+		return false;
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.length() == 2) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 2); // 下一级为前2位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)
+								&& dm2.length() == 4) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							// 获取第3级结点开始
+							List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+							String dm2Matching = dm2.substring(0, 4); // 下一级为前4位相同
+							for (int i3 = 0; i3 < dictList.size(); i3++) {
+								String dm3 = dictList.get(i3).getDm();
+								dm3 = StringUtils.nullToStr(dm3);
+								if (!dm3.equals(dm2)
+										&& dm3.startsWith(dm2Matching)) { // 第3级判断条件
+									TreeNode treeNode3 = new TreeNode();
+									mc = dictList.get(i3).getCt();
+									xt_zxbz = StringUtils.nullToStr(dictList
+											.get(i3).getXtZxbz());
+									if ("1".equals(xt_zxbz)) {
+										mc += "（已注销）";
+									}
+									py = dictList.get(i3).getPy();
+									treeNode3.setId(dm3);
+									treeNode3.setText(mc);
+									treeNode3.setPy(py);
+									nodeList3.add(treeNode3);
+								}
+							}
+							if (nodeList3.size() > 0) {
+								treeNode2.setState("closed");
+								treeNode2.setChildren(nodeList3);
+							}
+							// 获取第3级结点结束
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_ASJLYFLDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_GA_D_ASJLYFLDM extends DictTreeCreator {
+
+	private String treeName = "案事件来源分类代码";
+
+	public DictTree_GA_D_ASJLYFLDM() {
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+			String mc, py,wb, xt_zxbz;
+			List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if (dm1.endsWith("00")) { // 第1级判断条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						mc += "（已注销）";
+					}
+					py = dictList.get(i1).getPy();
+					wb = dictList.get(i1).getWb();
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					treeNode1.setWb(wb);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					String dm1Matching = dm1.substring(0, 2); // 下一级为前2位相同
+					for (int i2 = 0; i2 < dictList.size(); i2++) {
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if (!dm2.equals(dm1) && dm2.startsWith(dm1Matching)) { // 第2级判断条件
+							TreeNode treeNode2 = new TreeNode();
+							mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							wb = dictList.get(i2).getWb();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py);
+							treeNode2.setWb(wb);
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				}
+			}
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		} else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		}
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_ASJZCXWFLDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_GA_D_ASJZCXWFLDM  extends DictTreeCreator {
+	
+	private String treeName="案事件侦查行为分类代码";
+	
+	 public DictTree_GA_D_ASJZCXWFLDM() {
+
+	 }
+
+
+	@Override
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+		    String  mc, py, xt_zxbz;
+		    List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+		   
+		    for(int i1 = 0; i1 < dictList.size(); i1++){
+		    	String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if(dm1.endsWith("00") ){//第一级判定条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						continue;
+					}
+					py = dictList.get(i1).getPy();				
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					           
+					 String  dm1Matching=dm1.substring(0, dm1.length()-2);//下一级前2位相同
+					 
+					for(int i2 = 0; i2 < dictList.size(); i2++){
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if(!dm2.equals(dm1)&&dm2.startsWith(dm1Matching)
+								&&dm2.length()==dm1.length()){
+							TreeNode treeNode2 = new TreeNode();
+							 
+							 mc = dictList.get(i2).getCt();
+								xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+										.getXtZxbz());
+								if ("1".equals(xt_zxbz)) {
+									mc += "（已注销）";
+								}
+								py = dictList.get(i2).getPy();
+								treeNode2.setId(dm2);
+								treeNode2.setText(mc);
+								treeNode2.setPy(py);
+								nodeList2.add(treeNode2);
+						}
+						
+					} 
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				} 
+			
+		    }
+		    String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		   } else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！"); 
+		}		
+		
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_DYLBDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_GA_D_DYLBDM extends DictTreeCreator {
+
+	private String treeName="地域类别";
+	
+	
+	public DictTree_GA_D_DYLBDM() {
+
+
+	}
+
+
+	
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+		    String  mc, py, xt_zxbz;
+		    List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+		
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+			if(dm1.endsWith("000") ){//第一级判定条件
+				TreeNode treeNode1 = new TreeNode();
+				mc = dictList.get(i1).getCt();
+				xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+						.getXtZxbz());
+				if ("1".equals(xt_zxbz)) {
+					continue;
+				}
+				py = dictList.get(i1).getPy();				
+				treeNode1.setId(dm1);
+				treeNode1.setText(mc);
+				treeNode1.setPy(py);
+				
+				// 获取第2级结点开始
+				List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+				  String  dm1Matching=dm1.substring(0, 1);//下一级前1位相同
+				  for (int i2 = 0; i2 < dictList.size(); i2++) {
+					  String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);	  
+					 if(!dm2.equals(dm1) && dm2.startsWith(dm1Matching)
+								&& dm2.endsWith("0")){//第二级判定条件
+						 TreeNode treeNode2 = new TreeNode();
+						 
+						 mc = dictList.get(i2).getCt();
+							xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+									.getXtZxbz());
+							if ("1".equals(xt_zxbz)) {
+								mc += "（已注销）";
+							}
+							py = dictList.get(i2).getPy();
+							treeNode2.setId(dm2);
+							treeNode2.setText(mc);
+							treeNode2.setPy(py); 
+							
+							// 获取第3级结点开始
+							List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+							String dm2Matching = dm2.substring(0, 3); // 下一级为前3位相同
+							for (int i3 = 0; i3 < dictList.size(); i3++) {
+								String dm3 = dictList.get(i3).getDm();
+								dm3 = StringUtils.nullToStr(dm3);
+						  if(!dm3.equals(dm2) && dm3.startsWith(dm2Matching) 
+								  &&!dm3.endsWith("0")){
+							  TreeNode treeNode3 = new TreeNode();
+								mc = dictList.get(i3).getCt();
+								xt_zxbz = StringUtils.nullToStr(dictList
+										.get(i3).getXtZxbz());
+								if ("1".equals(xt_zxbz)) {
+									mc += "（已注销）";
+								}
+								py = dictList.get(i3).getPy();
+								treeNode3.setId(dm3);
+								treeNode3.setText(mc);
+								treeNode3.setPy(py);
+								nodeList3.add(treeNode3);
+							}		
+						  }
+							if (nodeList3.size() > 0) {
+								treeNode2.setState("closed");
+								treeNode2.setChildren(nodeList3);
+							}
+							// 获取第3级结点结束
+							nodeList2.add(treeNode2);
+						}
+					}
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				  }
+			   }	
+			
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		   } else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		 }	
+	 }
+	
+ }
+
+

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_DYXHDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public  class DictTree_GA_D_DYXHDM extends DictTreeCreator {
+
+	private String treeName="弹药型号代码";
+	
+	
+	
+	public DictTree_GA_D_DYXHDM() {
+		
+		
+	}
+
+	@Override
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+		    String  mc, py, xt_zxbz;
+		    List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+		   
+		    for(int i1 = 0; i1 < dictList.size(); i1++){
+		    	String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if(dm1.endsWith("00") ){//第一级判定条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						continue;
+					}
+					py = dictList.get(i1).getPy();				
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					           
+					 String  dm1Matching=dm1.substring(0, dm1.length()-2);//下一级前2位相同
+					 
+					for(int i2 = 0; i2 < dictList.size(); i2++){
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if(!dm2.equals(dm1)&&dm2.startsWith(dm1Matching)
+								&&dm2.length()==dm1.length()){
+							TreeNode treeNode2 = new TreeNode();
+							 
+							 mc = dictList.get(i2).getCt();
+								xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+										.getXtZxbz());
+								if ("1".equals(xt_zxbz)) {
+									mc += "（已注销）";
+								}
+								py = dictList.get(i2).getPy();
+								treeNode2.setId(dm2);
+								treeNode2.setText(mc);
+								treeNode2.setPy(py);
+								nodeList2.add(treeNode2);
+						}
+						
+					} 
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				} 
+			
+		    }
+		    String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		   } else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！"); 
+		}		
+		
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_GRZCSDDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Founder on 2017/5/2.
+ */
+public class DictTree_GA_D_GRZCSDDM extends DictTreeCreator {
+
+    private String treeName="干扰侦查手段代码";
+
+    public DictTree_GA_D_GRZCSDDM(){
+
+    }
+
+
+    @Override
+    public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+        List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+        if (dictList != null && dictList.size() > 0) { // 有数据
+            String dm,xt_zxbz;
+            //分组
+            List<SysDictForManager> dictList1=new ArrayList<SysDictForManager>();//一级
+            List<SysDictForManager> dictList2=new ArrayList<SysDictForManager>();//二级
+
+            for(int i = 0; i < dictList.size(); i++ ){
+                xt_zxbz = StringUtils.nullToStr(dictList.get(i).getXtZxbz());
+                if ("1".equals(xt_zxbz)) {
+                    continue;
+                }
+                dm = dictList.get(i).getDm();
+                if(dm.endsWith("00")){//第一级判定条件
+                    dictList1.add(dictList.get(i));
+                }else if(!dm.endsWith("0")){//第二级判定条件
+                    dictList2.add(dictList.get(i));
+                }
+            }
+
+            List<TreeNode> nodeList1 = new ArrayList<TreeNode>();//根节点
+            for(int j1 = 0; j1 < dictList1.size(); j1++) {//遍历根节点
+                String dm1 = dictList1.get(j1).getDm();
+                TreeNode treeNode1 = new TreeNode();
+                String mc1 = dictList1.get(j1).getCt();
+                String py1 = dictList1.get(j1).getPy();
+                treeNode1.setId(dm1);
+                treeNode1.setText(mc1);
+                treeNode1.setPy(py1);
+                String dmflag1=dm1.substring(0,1);//前1位相同
+                List<TreeNode> nodeList2 = new ArrayList<TreeNode>();//子节点
+                for (int j2 = 0; j2 < dictList2.size(); j2++) {//遍历子节点
+                    String	dm2 = dictList2.get(j2).getDm();
+                    if(dm2.startsWith(dmflag1)){
+                        String mc2 = dictList2.get(j2).getCt();
+                        String py2= dictList2.get(j2).getPy();
+                        TreeNode treeNode2 = new TreeNode();
+                        treeNode2.setId(dm2);
+                        treeNode2.setText(mc2);
+                        treeNode2.setPy(py2);
+                        nodeList2.add(treeNode2);
+                    }
+                }
+                if (nodeList2.size() > 0) {
+                    treeNode1.setState("closed");
+                    treeNode1.setChildren(nodeList2);
+                }
+                nodeList1.add(treeNode1);
+            }
+
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+                    + "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+                    + StringUtils.enterNewline + StringUtils.enterNewline);
+            fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+            fileWriter.write(StringUtils.enterNewline + "}]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        } else {
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        }
+
+    }
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_GXPCSDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class DictTree_GA_D_GXPCSDM extends DictTreeCreator{
+    private String treeName="管辖派出所代码";
+
+    @Override
+    public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+        List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+        if (dictList != null && dictList.size() > 0) { // 有数据
+            String dm,xt_zxbz;
+            //分组
+            List<SysDictForManager> dictList1=new ArrayList<SysDictForManager>();//一级
+            List<SysDictForManager> dictList2=new ArrayList<SysDictForManager>();//二级
+            Set<String> set =new HashSet<>();
+            for(int i = 0; i < dictList.size(); i++ ){
+                xt_zxbz = StringUtils.nullToStr(dictList.get(i).getXtZxbz());
+                if ("1".equals(xt_zxbz)) {
+                    continue;
+                }
+                dm = dictList.get(i).getDm();
+                String dmstart4=dm.substring(0,4);
+                boolean r=set.add(dmstart4);
+                if(r){
+                    if(dm.endsWith("00000000")){
+
+                    }
+                    dictList1.add(dictList.get(i));
+                }else{
+                    dictList2.add(dictList.get(i));
+                }
+            }
+
+            List<TreeNode> nodeList1 = new ArrayList<TreeNode>();//根节点
+            for(int j1 = 0; j1 < dictList1.size(); j1++) {//遍历根节点
+                String dm1 = dictList1.get(j1).getDm();
+                TreeNode treeNode1 = new TreeNode();
+                String mc1 = dictList1.get(j1).getCt();
+                String py1 = dictList1.get(j1).getPy();
+                treeNode1.setId(dm1);
+                treeNode1.setText(mc1);
+                treeNode1.setPy(py1);
+                String dmflag1=dm1.substring(0,4);//前1位相同
+                List<TreeNode> nodeList2 = new ArrayList<TreeNode>();//子节点
+                for (int j2 = 0; j2 < dictList2.size(); j2++) {//遍历子节点
+                    String	dm2 = dictList2.get(j2).getDm();
+                    if(dm2.startsWith(dmflag1)){
+                        String mc2 = dictList2.get(j2).getCt();
+                        String py2= dictList2.get(j2).getPy();
+                        TreeNode treeNode2 = new TreeNode();
+                        treeNode2.setId(dm2);
+                        treeNode2.setText(mc2);
+                        treeNode2.setPy(py2);
+                        nodeList2.add(treeNode2);
+                    }
+                }
+                if (nodeList2.size() > 0) {
+                    treeNode1.setState("closed");
+                    treeNode1.setChildren(nodeList2);
+                }
+                nodeList1.add(treeNode1);
+            }
+
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+                    + "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+                    + StringUtils.enterNewline + StringUtils.enterNewline);
+            fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+            fileWriter.write(StringUtils.enterNewline + "}]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        } else {
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        }
+    }
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_HYLBDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_GA_D_HYLBDM extends DictTreeCreator {
+
+    private String treeName = "行业类别";
+
+
+    public DictTree_GA_D_HYLBDM() {
+
+    }
+
+
+    @Override
+    public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+        List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+        if (dictList != null && dictList.size() > 0) { // 有数据
+            String dm, xt_zxbz;
+            //分组
+            List<SysDictForManager> dictList1 = new ArrayList<SysDictForManager>();//一级
+            List<SysDictForManager> dictList2 = new ArrayList<SysDictForManager>();//二级
+            List<SysDictForManager> dictList3 = new ArrayList<SysDictForManager>();//三级
+            List<SysDictForManager> dictList4 = new ArrayList<SysDictForManager>();//四级
+
+            for (int i = 0; i < dictList.size(); i++) {
+                xt_zxbz = StringUtils.nullToStr(dictList.get(i).getXtZxbz());
+                if ("1".equals(xt_zxbz)) {
+                    continue;
+                }
+                dm = dictList.get(i).getDm();
+                if (dm.endsWith("0000")) {//第一级判定条件
+                    dictList1.add(dictList.get(i));
+                } else if (dm.endsWith("00") && !dm.endsWith("0000")) {//第二级判定条件
+                    dictList2.add(dictList.get(i));
+                } else if (dm.endsWith("0") && !dm.endsWith("0000") && !dm.endsWith("00")) {//第三级判定条件
+                    dictList3.add(dictList.get(i));
+                } else if (!dm.endsWith("0")) {//第四级级判定条件
+                    dictList4.add(dictList.get(i));
+                }
+            }
+
+            List<TreeNode> nodeList1 = new ArrayList<TreeNode>();//根节点
+            for (int j1 = 0; j1 < dictList1.size(); j1++) {//遍历根节点
+                String dm1 = dictList1.get(j1).getDm();
+                TreeNode treeNode1 = new TreeNode();
+                String mc1 = dictList1.get(j1).getCt();
+                String py1 = dictList1.get(j1).getPy();
+                treeNode1.setId(dm1);
+                treeNode1.setText(mc1);
+                treeNode1.setPy(py1);
+                String dmflag1 = dm1.substring(0, 1);//前1位相同
+                List<TreeNode> nodeList2 = new ArrayList<TreeNode>();//子节点
+                for (int j2 = 0; j2 < dictList2.size(); j2++) {//遍历子节点
+                    String dm2 = dictList2.get(j2).getDm();
+                    if (dm2.startsWith(dmflag1)) {
+                        String mc2 = dictList2.get(j2).getCt();
+                        String py2 = dictList2.get(j2).getPy();
+                        TreeNode treeNode2 = new TreeNode();
+                        treeNode2.setId(dm2);
+                        treeNode2.setText(mc2);
+                        treeNode2.setPy(py2);
+                        String dmflag2 = dm2.substring(0, 3);//前3位相同
+                        List<TreeNode> nodeList3 = new ArrayList<TreeNode>();//孙节点
+                        for (int j3 = 0; j3 < dictList3.size(); j3++) {//遍历孙节点
+                            String dm3 = dictList3.get(j3).getDm();
+                            if (dm3.startsWith(dmflag2)) {
+                                TreeNode treeNode3 = new TreeNode();
+                                String mc3 = dictList3.get(j3).getCt();
+                                String py3 = dictList3.get(j3).getPy();
+                                treeNode3.setId(dm3);
+                                treeNode3.setText(mc3);
+                                treeNode3.setPy(py3);
+                                String dmflag3 = dm3.substring(0, 4);//前四位相同
+                                List<TreeNode> nodeList4 = new ArrayList<TreeNode>();//曾孙节点
+                                for (int j4 = 0; j4 < dictList4.size(); j4++) {//遍历曾孙节点
+                                    String dm4 = dictList4.get(j4).getDm();
+                                    if (dm4.startsWith(dmflag3)) {
+                                        TreeNode treeNode4 = new TreeNode();
+                                        String mc4 = dictList4.get(j4).getCt();
+                                        String py4 = dictList4.get(j4).getPy();
+                                        treeNode4.setId(dm4);
+                                        treeNode4.setText(mc4);
+                                        treeNode4.setPy(py4);
+                                        nodeList4.add(treeNode4);
+                                    }
+                                }
+                                if (nodeList4.size() > 0) {
+                                    treeNode3.setState("closed");
+                                    treeNode3.setChildren(nodeList4);
+                                }
+                                nodeList3.add(treeNode3);
+                            }
+                        }
+                        if (nodeList3.size() > 0) {
+                            treeNode2.setState("closed");
+                            treeNode2.setChildren(nodeList3);
+                        }
+                        nodeList2.add(treeNode2);
+                    }
+                }
+                if (nodeList2.size() > 0) {
+                    treeNode1.setState("closed");
+                    treeNode1.setChildren(nodeList2);
+                }
+                nodeList1.add(treeNode1);
+            }
+
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+                    + "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+                    + StringUtils.enterNewline + StringUtils.enterNewline);
+            fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+            fileWriter.write(StringUtils.enterNewline + "}]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        } else {
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        }
+
+    }
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_JLDLDWDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_GA_D_JLDLDWDM extends DictTreeCreator {
+
+	private String treeName="计量度量单位";
+	
+	
+	@Override
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+		    String  mc, py, xt_zxbz;
+		    List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+		   
+		    for(int i1 = 0; i1 < dictList.size(); i1++){
+		    	String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);   
+				if(dm1.endsWith("00") ){//第一级判定条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						continue;
+					}
+					py = dictList.get(i1).getPy();				
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					           
+					 String  dm1Matching=dm1.substring(0, dm1.length()-2);//下一级前2位相同
+					 
+					for(int i2 = 0; i2 < dictList.size(); i2++){
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if(!dm2.equals(dm1)&&dm2.startsWith(dm1Matching)
+								&&dm2.length()==dm1.length()){
+							TreeNode treeNode2 = new TreeNode();
+							 
+							 mc = dictList.get(i2).getCt();
+								xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+										.getXtZxbz());
+								if ("1".equals(xt_zxbz)) {
+									mc += "（已注销）";
+								}
+								py = dictList.get(i2).getPy();
+								treeNode2.setId(dm2);
+								treeNode2.setText(mc);
+								treeNode2.setPy(py);															
+							// 获取第3级结点结束
+								nodeList2.add(treeNode2);
+						}
+						
+					} 
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				} 
+			
+		    }
+		    String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		   } else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！"); 
+		}		
+		
+	}
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_JSSDFLDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Founder on 2017/5/2.
+ */
+public class DictTree_GA_D_JSSDFLDM extends DictTreeCreator {
+
+    private String treeName="解锁手段代码";
+
+    public DictTree_GA_D_JSSDFLDM(){
+
+    }
+
+    @Override
+    public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+
+        List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+        if (dictList != null && dictList.size() > 0) { // 有数据
+            String dm,xt_zxbz;
+            //分组
+            List<SysDictForManager> dictList1=new ArrayList<SysDictForManager>();//一级
+            List<SysDictForManager> dictList2=new ArrayList<SysDictForManager>();//二级
+
+            for(int i = 0; i < dictList.size(); i++ ){
+                xt_zxbz = StringUtils.nullToStr(dictList.get(i).getXtZxbz());
+                if ("1".equals(xt_zxbz)) {
+                    continue;
+                }
+                dm = dictList.get(i).getDm();
+                if(dm.endsWith("0")){//第一级判定条件
+                    dictList1.add(dictList.get(i));
+                }else if(!dm.endsWith("0")){//第二级判定条件
+                    dictList2.add(dictList.get(i));
+                }
+            }
+
+            List<TreeNode> nodeList1 = new ArrayList<TreeNode>();//根节点
+            for(int j1 = 0; j1 < dictList1.size(); j1++) {//遍历根节点
+                String dm1 = dictList1.get(j1).getDm();
+                TreeNode treeNode1 = new TreeNode();
+                String mc1 = dictList1.get(j1).getCt();
+                String py1 = dictList1.get(j1).getPy();
+                treeNode1.setId(dm1);
+                treeNode1.setText(mc1);
+                treeNode1.setPy(py1);
+                String dmflag1=dm1.substring(0,1);//前1位相同
+                List<TreeNode> nodeList2 = new ArrayList<TreeNode>();//子节点
+                for (int j2 = 0; j2 < dictList2.size(); j2++) {//遍历子节点
+                    String	dm2 = dictList2.get(j2).getDm();
+                    if(dm2.startsWith(dmflag1)){
+                        String mc2 = dictList2.get(j2).getCt();
+                        String py2= dictList2.get(j2).getPy();
+                        TreeNode treeNode2 = new TreeNode();
+                        treeNode2.setId(dm2);
+                        treeNode2.setText(mc2);
+                        treeNode2.setPy(py2);
+                        nodeList2.add(treeNode2);
+                    }
+                }
+                if (nodeList2.size() > 0) {
+                    treeNode1.setState("closed");
+                    treeNode1.setChildren(nodeList2);
+                }
+                nodeList1.add(treeNode1);
+            }
+
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+                    + "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+                    + StringUtils.enterNewline + StringUtils.enterNewline);
+            fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+            fileWriter.write(StringUtils.enterNewline + "}]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        } else {
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        }
+
+    }
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_KJBWDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_GA_D_KJBWDM extends DictTreeCreator {
+
+	private String treeName="空间部位";
+	
+	
+	public DictTree_GA_D_KJBWDM() {
+	
+	}
+
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+		    String  mc, py, xt_zxbz;
+		    List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+		
+			for (int i1 = 0; i1 < dictList.size(); i1++) {
+				String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+			    if(dm1.endsWith("00")){//第一级判定条件
+			    	TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						continue;
+					}
+					py = dictList.get(i1).getPy();				
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+			       //获取第二级开始节点
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					 String  dm1Matching=dm1.substring(0, 1);//下一级前1位相同
+					 for (int i2 = 0; i2 < dictList.size(); i2++) {
+						 String dm2 = dictList.get(i2).getDm();
+							dm2 = StringUtils.nullToStr(dm2); 
+						if(!dm2.equals(dm1)&&dm2.startsWith(dm1Matching) ){//第二级判定条件
+							TreeNode treeNode2 = new TreeNode();
+							 
+							 mc = dictList.get(i2).getCt();
+								xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+										.getXtZxbz());
+								if ("1".equals(xt_zxbz)) {
+									mc += "（已注销）";
+								}
+								py = dictList.get(i2).getPy();
+								treeNode2.setId(dm2);
+								treeNode2.setText(mc);
+								treeNode2.setPy(py); 
+								nodeList2.add(treeNode2);
+						 } 
+						
+					 }
+					   if (nodeList2.size() > 0) {
+							treeNode1.setState("closed");
+							treeNode1.setChildren(nodeList2);
+						}
+						// 获取第2级结点结束
+						nodeList1.add(treeNode1);
+					 
+				 }	
+			 
+			}	
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		   } else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");	
+	   }
+    }  
+
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_KJFWDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 编写方法测试，为使用。行政区划
+ * Created by Founder on 2017/4/27.
+ */
+public class DictTree_GA_D_KJFWDM extends DictTreeCreator {
+
+    private String treeName="跨界范围";
+
+    public DictTree_GA_D_KJFWDM(){
+
+    }
+
+    @Override
+    public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+        List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+        if (dictList != null && dictList.size() > 0) { // 有数据
+            String dm,xt_zxbz;
+            //分组
+            List<SysDictForManager> dictList1=new ArrayList<SysDictForManager>();//一级
+            List<SysDictForManager> dictList2=new ArrayList<SysDictForManager>();//二级
+
+            for(int i = 0; i < dictList.size(); i++ ){
+                xt_zxbz = StringUtils.nullToStr(dictList.get(i).getXtZxbz());
+                if ("1".equals(xt_zxbz)) {
+                    continue;
+                }
+                dm = dictList.get(i).getDm();
+                if(dm.endsWith("0")){//第一级判定条件
+                    dictList1.add(dictList.get(i));
+                }else {//第二级判定条件
+                    dictList2.add(dictList.get(i));
+                }
+            }
+
+            List<TreeNode> nodeList1 = new ArrayList<TreeNode>();//根节点
+            for(int j1 = 0; j1 < dictList1.size(); j1++) {//遍历根节点
+                String dm1 = dictList1.get(j1).getDm();
+                TreeNode treeNode1 = new TreeNode();
+                String mc1 = dictList1.get(j1).getCt();
+                String py1 = dictList1.get(j1).getPy();
+                treeNode1.setId(dm1);
+                treeNode1.setText(mc1);
+                treeNode1.setPy(py1);
+                String dmflag1=dm1.substring(0,2);//前两位相同
+                List<TreeNode> nodeList2 = new ArrayList<TreeNode>();//子节点
+                for (int j2 = 0; j2 < dictList2.size(); j2++) {//遍历子节点
+                    String	dm2 = dictList2.get(j2).getDm();
+                    if(dm2.startsWith(dmflag1)){
+                        String mc2 = dictList2.get(j2).getCt();
+                        String py2= dictList2.get(j2).getPy();
+                        TreeNode treeNode2 = new TreeNode();
+                        treeNode2.setId(dm2);
+                        treeNode2.setText(mc2);
+                        treeNode2.setPy(py2);
+                        nodeList2.add(treeNode2);
+                    }
+
+                }
+
+                if (nodeList2.size() > 0) {
+                    treeNode1.setState("closed");
+                    treeNode1.setChildren(nodeList2);
+                }
+                nodeList1.add(treeNode1);
+            }
+
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+                    + "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+                    + StringUtils.enterNewline + StringUtils.enterNewline);
+            fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+            fileWriter.write(StringUtils.enterNewline + "}]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        } else {
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        }
+
+
+
+    }
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_QQSDFLDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Founder on 2017/5/2.
+ */
+public class DictTree_GA_D_QQSDFLDM extends DictTreeCreator {
+
+    private String treeName="窃取手段代码";
+
+    public DictTree_GA_D_QQSDFLDM(){
+
+    }
+    @Override
+    public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+
+        List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+        if (dictList != null && dictList.size() > 0) { // 有数据
+            String dm,xt_zxbz;
+            //分组
+            List<SysDictForManager> dictList1=new ArrayList<SysDictForManager>();//一级
+            List<SysDictForManager> dictList2=new ArrayList<SysDictForManager>();//二级
+
+            for(int i = 0; i < dictList.size(); i++ ){
+                xt_zxbz = StringUtils.nullToStr(dictList.get(i).getXtZxbz());
+                if ("1".equals(xt_zxbz)) {
+                    continue;
+                }
+                dm = dictList.get(i).getDm();
+                if(dm.endsWith("00")){//第一级判定条件
+                    dictList1.add(dictList.get(i));
+                }else if(!dm.endsWith("0")){//第二级判定条件
+                    dictList2.add(dictList.get(i));
+                }
+            }
+
+            List<TreeNode> nodeList1 = new ArrayList<TreeNode>();//根节点
+            for(int j1 = 0; j1 < dictList1.size(); j1++) {//遍历根节点
+                String dm1 = dictList1.get(j1).getDm();
+                TreeNode treeNode1 = new TreeNode();
+                String mc1 = dictList1.get(j1).getCt();
+                String py1 = dictList1.get(j1).getPy();
+                treeNode1.setId(dm1);
+                treeNode1.setText(mc1);
+                treeNode1.setPy(py1);
+                String dmflag1=dm1.substring(0,2);//前2位相同
+                List<TreeNode> nodeList2 = new ArrayList<TreeNode>();//子节点
+                for (int j2 = 0; j2 < dictList2.size(); j2++) {//遍历子节点
+                    String	dm2 = dictList2.get(j2).getDm();
+                    if(dm2.startsWith(dmflag1)){
+                        String mc2 = dictList2.get(j2).getCt();
+                        String py2= dictList2.get(j2).getPy();
+                        TreeNode treeNode2 = new TreeNode();
+                        treeNode2.setId(dm2);
+                        treeNode2.setText(mc2);
+                        treeNode2.setPy(py2);
+                        nodeList2.add(treeNode2);
+                    }
+                }
+                if (nodeList2.size() > 0) {
+                    treeNode1.setState("closed");
+                    treeNode1.setChildren(nodeList2);
+                }
+                nodeList1.add(treeNode1);
+            }
+
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+                    + "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+                    + StringUtils.enterNewline + StringUtils.enterNewline);
+            fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+            fileWriter.write(StringUtils.enterNewline + "}]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        } else {
+            String tableNameUpper = zdbh.toUpperCase();
+            Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+                    JSPath + tableNameUpper + ".js"), "UTF8");
+            fileWriter.write("[]");
+            fileWriter.flush();
+            fileWriter.close();
+            System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+            System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+        }
+    }
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_QZXHDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public   class DictTree_GA_D_QZXHDM extends DictTreeCreator {
+	
+	private String treeName="枪支型号代码";
+
+	public DictTree_GA_D_QZXHDM() {
+		
+	}
+
+	@Override
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+		    String  mc, py, xt_zxbz;
+		    List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+		    for(int i1 = 0; i1 < dictList.size(); i1++){
+		    	String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if(dm1.endsWith("00") ){//第一级判定条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						continue;
+					}
+					py = dictList.get(i1).getPy();				
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					           
+					 String  dm1Matching=dm1.substring(0, dm1.length()-2);//下一级前2位相同
+					 
+					for(int i2 = 0; i2 < dictList.size(); i2++){
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if(!dm2.equals(dm1)&&dm2.startsWith(dm1Matching)
+								&&dm2.length()==dm1.length()){
+							TreeNode treeNode2 = new TreeNode();
+							 
+							 mc = dictList.get(i2).getCt();
+								xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+										.getXtZxbz());
+								if ("1".equals(xt_zxbz)) {
+									mc += "（已注销）";
+								}
+								py = dictList.get(i2).getPy();
+								treeNode2.setId(dm2);
+								treeNode2.setText(mc);
+								treeNode2.setPy(py);
+								nodeList2.add(treeNode2);
+						}
+						
+					} 
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				} 
+			
+		    }
+		    String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		   } else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！"); 
+		}			
+				
+				
+	}
+	
+    
+}

src/main/java/com/founder/dictmanager/dictionary/service/DictTree_GA_D_SACSFLDM.java

+package com.founder.dictmanager.dictionary.service;
+
+import com.founder.framework.utils.StringUtils;
+import com.founder.framework.utils.TreeDataBuilder;
+import com.founder.framework.utils.TreeNode;
+import com.founder.dictmanager.model.SysDictForManager;
+
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+public class DictTree_GA_D_SACSFLDM extends DictTreeCreator {
+
+	private String treeName="涉案场所分类";
+		
+	
+	public DictTree_GA_D_SACSFLDM() {
+		
+	}
+
+	public void createTreeJS(String zdbh, String zdbhMc) throws Exception {
+		List<SysDictForManager> dictList = super.getSysDictDao().queryListByZdbh(zdbh);
+		if (dictList != null && dictList.size() > 0) { // 有数据
+		    String  mc, py, xt_zxbz;
+		    List<TreeNode> nodeList1 = new ArrayList<TreeNode>();
+		   
+		    for(int i1 = 0; i1 < dictList.size(); i1++){
+		    	String dm1 = dictList.get(i1).getDm();
+				dm1 = StringUtils.nullToStr(dm1);
+				if(dm1.endsWith("00") ){//第一级判定条件
+					TreeNode treeNode1 = new TreeNode();
+					mc = dictList.get(i1).getCt();
+					xt_zxbz = StringUtils.nullToStr(dictList.get(i1)
+							.getXtZxbz());
+					if ("1".equals(xt_zxbz)) {
+						continue;
+					}
+					py = dictList.get(i1).getPy();				
+					treeNode1.setId(dm1);
+					treeNode1.setText(mc);
+					treeNode1.setPy(py);
+					// 获取第2级结点开始
+					List<TreeNode> nodeList2 = new ArrayList<TreeNode>();
+					           
+					 String  dm1Matching=dm1.substring(0, dm1.length()-2);//下一级前1位相同
+					 
+					for(int i2 = 0; i2 < dictList.size(); i2++){
+						String dm2 = dictList.get(i2).getDm();
+						dm2 = StringUtils.nullToStr(dm2);
+						if(!dm2.equals(dm1)&&dm2.startsWith(dm1Matching)
+								&&dm2.length()==dm1.length()){
+							TreeNode treeNode2 = new TreeNode();
+							 
+							 mc = dictList.get(i2).getCt();
+								xt_zxbz = StringUtils.nullToStr(dictList.get(i2)
+										.getXtZxbz());
+								if ("1".equals(xt_zxbz)) {
+									mc += "（已注销）";
+								}
+								py = dictList.get(i2).getPy();
+								treeNode2.setId(dm2);
+								treeNode2.setText(mc);
+								treeNode2.setPy(py);
+
+							// 获取第3级结点开始
+							List<TreeNode> nodeList3 = new ArrayList<TreeNode>();
+							String dm2Matching = dm2.substring(0, 4); // 下一级为前4位相同
+							for (int i3 = 0; i3 < dictList.size(); i3++) {
+								String dm3 = dictList.get(i3).getDm();
+								dm3 = StringUtils.nullToStr(dm3);
+								if (!dm3.equals(dm2)
+										&& dm3.startsWith(dm2Matching)) { // 第3级判断条件
+									TreeNode treeNode3 = new TreeNode();
+									mc = dictList.get(i3).getCt();
+									xt_zxbz = StringUtils.nullToStr(dictList
+											.get(i3).getXtZxbz());
+									if ("1".equals(xt_zxbz)) {
+										mc += "（已注销）";
+									}
+									py = dictList.get(i3).getPy();
+									treeNode3.setId(dm3);
+									treeNode3.setText(mc);
+									treeNode3.setPy(py);
+									nodeList3.add(treeNode3);
+								}
+							}
+							if (nodeList3.size() > 0) {
+								treeNode2.setState("closed");
+								treeNode2.setChildren(nodeList3);
+							}
+							// 获取第3级结点结束
+
+								nodeList2.add(treeNode2);
+						}
+						
+					} 
+					if (nodeList2.size() > 0) {
+						treeNode1.setState("closed");
+						treeNode1.setChildren(nodeList2);
+					}
+					// 获取第2级结点结束
+					nodeList1.add(treeNode1);
+				} 
+			
+		    }
+		    String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[{\"id\":\"ROOT\",\"text\":\"" + zdbhMc
+					+ "\",\"iconCls\":\"icon-treeroot1\",\"children\":"
+					+ StringUtils.enterNewline + StringUtils.enterNewline);
+			fileWriter.write(TreeDataBuilder.getTreeData(nodeList1));
+			fileWriter.write(StringUtils.enterNewline + "}]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！");
+		   } else {
+			String tableNameUpper = zdbh.toUpperCase();
+			Writer fileWriter = new OutputStreamWriter(new FileOutputStream(
+					JSPath + tableNameUpper + ".js"), "UTF8");
+			fileWriter.write("[]");
+			fileWriter.flush();
+			fileWriter.close();
+			System.out.println("字典： " + treeName + " 无数据， 创建空文件成功！");
+			System.out.println("文件 ：" + tableNameUpper + ".js 创建成功！"); 
+		}		
+	}
+
+}