526互联

package com.ws.byd.bmgl.bmzdpz:编码字典------bydobject

发布时间 2023-07-06 19:24:54作者: 初晓臻


controller:




package com.ws.byd.bmgl.bmzdpz.controller;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import com.ws.byd.bmgl.bmzdpz.service.BmzdpzManager;
import com.ws.byd.jcsj.gxgl.service.GxglManager;
import com.ws.core.utils.DateUtils;
import com.ws.core.web.utils.Pager;
import com.ws.sys.core.model.User;
import com.ws.sys.core.utils.IDGenerator;
import com.ws.sys.core.utils.JsonUtil;
import com.ws.sys.core.web.controller.BaseController;
@Controller
@RequestMapping("/byd/bmzdpz/")
public class BmzdpzController extends BaseController {

	@Autowired
	private BmzdpzManager bmzdpzManager;
	
	@RequestMapping("bmzdpzQuery")
	public ModelAndView bmzdpzQuery(HttpServletRequest request){
		ModelAndView mav = new ModelAndView("/byd/bmgl/bmzdpz/bmzdpz_query_ztree");
		Map<String,String> map = super.getParamValues(request);
		mav.addObject("map", map);
		return mav;
	}
	
	@RequestMapping("bmzdpzZtree")
	public void bmzdpzZtree(HttpServletRequest request,HttpServletResponse response){
		Map<String,String> map = super.getParamValues(request);
		User user = (User) request.getSession().getAttribute("userm");
		List<Map> treeList = bmzdpzManager.getBmzdpzZtree(map);
		super.flushResponse(response, JsonUtil.toJson(treeList));
	}
	
	@RequestMapping("bmzdpzListQuery")
	public ModelAndView bmzdpzListQuery(HttpServletRequest request){
		ModelAndView mav = new ModelAndView("/byd/bmgl/bmzdpz/bmzdpz_query_list");
		Map map = super.getParamValues(request);
		map = super.pageXX(map, request);
		Pager pager = bmzdpzManager.getBmzdpzListQuery(map);
		mav.addObject("pager", pager);
		mav.addObject("map", map);
		return mav;
	}
	
	@RequestMapping("bmzdpzZdxAdd")
	public ModelAndView bmzdpzZdxAdd(HttpServletRequest request){
		ModelAndView mav = new ModelAndView("/byd/bmgl/bmzdpz/bmzdpz_zdx_add");
		Map map = super.getParamValues(request);
		mav.addObject("map", map);
		return mav;
	}
	
	@RequestMapping("bmzdpzZdxIsExists")
	public void bmzdpzZdxIsExists(HttpServletRequest request,HttpServletResponse response){
		int count = 0;
		Map<String,String> map = super.getParamValues(request);
		List<Map> resultList = bmzdpzManager.getBmzdpzZdxList(map);
		if(null != resultList && resultList.size() > 0) {
			count = 1;
		}
		super.flushResponse(response, String.valueOf(count));
	}
	
	@RequestMapping("bmzdpzZdxAddSave")
	public void bmzdpzZdxAddSave(HttpServletRequest request,HttpServletResponse response){
		Map map = super.getParamValues(request);
		Map<String,String[]> maps = getParameterValues(request);
		User user = (User) request.getSession().getAttribute("userm");
		map.put("djrxm", user.getName());
		map.put("djrgh", user.getIdnumber());
		map.put("djsj", DateUtils.getCurrentTimeAs14String());
		int count = bmzdpzManager.getBmzdpzZdxAddSave(map,maps);
		super.flushResponse(response, String.valueOf(count));
	}
	
	@RequestMapping("bmzdpzZdxEdit")
	public ModelAndView bmzdpzZdxEdit(HttpServletRequest request){
		ModelAndView mav = new ModelAndView("/byd/bmgl/bmzdpz/bmzdpz_zdx_edit");
		Map map = super.getParamValues(request);
		Map resultMap = new HashMap();
		List<Map> resultList = bmzdpzManager.getBmzdpzZdxList(map);
		if(null != resultList && resultList.size() > 0) {
			resultMap = resultList.get(0);
		}
		mav.addObject("resultMap", resultMap);
		mav.addObject("map", map);
		return mav;
	}

	@RequestMapping("bmzdpzZdxEditSave")
	public void bmzdpzZdxEditSave(HttpServletRequest request,HttpServletResponse response){
		Map map = super.getParamValues(request);
		int count = bmzdpzManager.getBmzdpzZdxEditSave(map);
		super.flushResponse(response, String.valueOf(count));
	}
	
	@RequestMapping("bmzdpzZdxDeleteSave")
	public void bmzdpzZdxDelete(HttpServletRequest request,HttpServletResponse response){
		Map map = super.getParamValues(request);
		int count = 0;
		List<Map> list = bmzdpzManager.getBmzdpzgzQuery(map);
		if(list.size() == 0) {
			count = bmzdpzManager.getBmzdpzZdxDelSave(map);
		}
		super.flushResponse(response, String.valueOf(count));
	}
	
}





　　






service:

interface BmzdpzManager----》


BmzdpzManagerImpl implements BmzdpzManager-------》


BmzdpzSql


 


 


接口




package com.ws.byd.bmgl.bmzdpz.service;

import java.util.List;
import java.util.Map;

import com.ws.core.web.utils.Pager;

public interface BmzdpzManager {

	List<Map> getBmzdpzZtree(Map map);
	
	Pager<Map<String,Object>> getBmzdpzListQuery(Map map);
	
	List<Map> getBmzdpzZdxList(Map map);
	
	int getBmzdpzZdxAddSave(Map map,Map<String,String[]> maps);
	
	int getBmzdpzZdxEditSave(Map map);

	int getBmzdpzZdxDelSave(Map map);

	Map<String,String> getBmzdpzZdx();
	
	List<Map> getBmzdpzgzQuery(Map map);
}





　　BmzdpzManagerImpl




package com.ws.byd.bmgl.bmzdpz.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.annotation.Resource;

import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ws.byd.bmgl.bmzdpz.service.BmzdpzManager;
import com.ws.byd.bmgl.util.BmzdCacheUtil;
import com.ws.byd.htgl.ftpgl.service.impl.FtpglSql;
import com.ws.byd.htgl.jsgl.service.impl.JsglSql;
import com.ws.byd.htgl.mkgl.service.impl.MkglSql;
import com.ws.byd.jcsj.gxgl.service.GxglManager;
import com.ws.byd.jcsj.lglr.service.impl.LglrSql;
import com.ws.byd.jcsj.pcbagslr.service.impl.PcbagslrSql;
import com.ws.core.web.utils.Pager;
import com.ws.db.modle.SqlBuilder;
import com.ws.db.service.SqlExecuteManager;
import com.ws.sys.core.utils.IDGenerator;
@Service("bmzdpzManager")
public class BmzdpzManagerImpl implements BmzdpzManager {
	
	@Autowired
    private SqlExecuteManager sqlExecuteManager;
	@Resource(name = "sqlSessionFactory_2")
    private SqlSessionFactory sqlSessionFactory_2;

	@Override
	public List<Map> getBmzdpzZtree(Map map) {
		List<Map> treeList = new ArrayList<Map>();
		Map rootMap = new HashMap();
		rootMap.put("id", "0");
		rootMap.put("pid", "");
		rootMap.put("mc", "编码字典");
		rootMap.put("dm", "root");
		rootMap.put("level", "0");
		treeList.add(rootMap);
		String sql = BmzdpzSql.getBmzdpzListSql(map);
		SqlBuilder sqlBuilder = new SqlBuilder(sql);
		List<Map> resultList = sqlExecuteManager.getResultList(sqlBuilder, sqlSessionFactory_2);
		treeList.addAll(resultList);
		return treeList;
	}

	@Override
	public Pager<Map<String, Object>> getBmzdpzListQuery(Map map) {
		int page = 1;
		int pageSize = 10;
		if(map.get("pageNumber") != null && !"".equals(map.get("pageNumber").toString())){
			page = Integer.parseInt(map.get("pageNumber").toString());
		}
		if(map.get("pageSize") != null && !"".equals(map.get("pageSize").toString())){
			pageSize = Integer.parseInt(map.get("pageSize").toString());
		}
		String sql = BmzdpzSql.getBmzdpzListSql(map);
		int count = sqlExecuteManager.getFalseResultCount(new SqlBuilder(sql), sqlSessionFactory_2);
		Pager<Map<String, Object>> pager = new Pager<Map<String, Object>>(count, pageSize, page);
		List<Map<String, Object>> resulList = sqlExecuteManager.getResultList(new SqlBuilder(sql+" limit "+pager.getStartIndex()+","+pageSize), sqlSessionFactory_2);
		pager.setResults(resulList);
		return pager;
	}

	@Override
	public List<Map> getBmzdpzZdxList(Map map) {
		return sqlExecuteManager.getResultList(new SqlBuilder(BmzdpzSql.getBmzdpzListSql(map)), sqlSessionFactory_2);
	}

	@Transactional("txManager_2")
	@Override
	public int getBmzdpzZdxAddSave(Map map, Map<String, String[]> maps) {
		int count = 0;
		List<Map> zdxList = new ArrayList<Map>();
		String[] mc = maps.get("mc");
		String[] dm = maps.get("dm");
		for(int i=0;i<dm.length;i++) {
			Map zdxMap = new HashMap();
			zdxMap.put("id", IDGenerator.getUid());
			zdxMap.put("pid", map.get("pid"));
			zdxMap.put("mc", mc[i]);
			zdxMap.put("dm", dm[i]);
			zdxMap.put("level", "2");
			zdxMap.put("djrgh", map.get("djrgh"));
			zdxMap.put("djrxm", map.get("djrxm"));
			zdxMap.put("djsj", map.get("djsj"));
			zdxList.add(zdxMap);
		}
		count += sqlExecuteManager.insertBath(new SqlBuilder(BmzdpzSql.insertBmzdpzZdxSql(map),zdxList), sqlSessionFactory_2);
		BmzdCacheUtil.getInstance().flushBmzdCache();
		return count;
	}

	@Override
	public int getBmzdpzZdxEditSave(Map map) {
		int count = 0;
		BmzdCacheUtil.getInstance().flushBmzdCache();
		count += sqlExecuteManager.update(new SqlBuilder(BmzdpzSql.updateBmzdpzZdxSql(map)), sqlSessionFactory_2);
		return count;
	}

	@Override
	public int getBmzdpzZdxDelSave(Map map) {
		int count = 0;
		BmzdCacheUtil.getInstance().flushBmzdCache();
		count += sqlExecuteManager.delete(new SqlBuilder(BmzdpzSql.deleteBmzdpzZdxSql(map)), sqlSessionFactory_2);
		return count;
	}

	@Override
	public List<Map> getBmzdpzgzQuery(Map map) {
		return sqlExecuteManager.getResultList(new SqlBuilder(BmzdpzSql.getBmzdpzgzSql(map)), sqlSessionFactory_2);
	}
	
	@Override
	public Map<String, String> getBmzdpzZdx() {
		Map<String, String> zdxMap = new HashMap<String, String>();
		Map<String,String> param = new HashMap<String, String>();
		param.put("level", "2");
		String sql = BmzdpzSql.getBmzdpzListSql(param);
		SqlBuilder sqlBuilder = new SqlBuilder(sql);
		List<Map> resultList = sqlExecuteManager.getResultList(sqlBuilder, sqlSessionFactory_2);
		for(Map result:resultList) {
			zdxMap.put(ObjectUtils.toString(result.get("id")), ObjectUtils.toString(result.get("mc")));
		}
		return zdxMap;
	}

}





　　


BmzdpzSql




package com.ws.byd.bmgl.bmzdpz.service.impl;

import java.util.Map;

import com.ws.common.utils.GetCanShuUtil;

public class BmzdpzSql extends GetCanShuUtil {

	public static String getBmzdpzListSql(Map map) {
		StringBuffer sql = new StringBuffer();
		sql.append("select t.id,t.pid,t.mc,t.dm,t.level from t_bmgl_zdxx t where 1=1");
		if(!isEmpty(map, "fid")) {
			sql.append(" and t.pid = "+getCanShu(map, "fid"));
		}
		if(!isEmpty(map, "id")) {
			sql.append(" and t.id = "+getCanShu(map, "id"));
		}
		if(!isEmpty(map, "ckdm")) {
			sql.append(" and t.dm = "+getCanShu(map, "dm"));
		}
		if(!isEmpty(map, "mc")) {
			sql.append(" and t.mc like "+getCanShuLike(map, "mc","1"));
		}
		if(!isEmpty(map, "dm")) {
			sql.append(" and t.dm like "+getCanShuLike(map, "dm","1"));
		}
		if(!isEmpty(map, "level")) {
			sql.append(" and t.level = "+getCanShu(map, "level"));
			sql.append(" order by t.id");
		}else {
			sql.append(" order by t.id desc");
		}
		return sql.toString();
	}
	
	public static String insertBmzdpzZdxSql(Map map) {
		StringBuffer sql = new StringBuffer();
		sql.append("insert into t_bmgl_zdxx (id,pid,mc,dm,level,djrgh,djrxm,djsj)");
		sql.append(" values(");
		sql.append("#{id,jdbcType=VARCHAR},#{pid,jdbcType=VARCHAR},#{mc,jdbcType=VARCHAR},#{dm,jdbcType=VARCHAR},");
		sql.append("#{level,jdbcType=VARCHAR},#{djrgh,jdbcType=VARCHAR},#{djrxm,jdbcType=VARCHAR},#{djsj,jdbcType=VARCHAR}");
		sql.append(")");
		return sql.toString();
	}
	
	public static String updateBmzdpzZdxSql(Map map) {
		StringBuffer sql = new StringBuffer();
		sql.append("update t_bmgl_zdxx set ");
		sql.append("mc="+getCanShu(map, "mc"));
		sql.append(" where id="+getCanShu(map, "id"));
		return sql.toString();
	}
	
	public static String deleteBmzdpzZdxSql(Map map) {
		String sql = "delete from t_bmgl_zdxx where id="+getCanShu(map, "id");
		return sql;
	}
	
	public static String getBmzdpzgzSql(Map map) {
		String sql = "select * from t_bmgl_gzxx where gzid like "+getCanShuLike(map, "id", "1");
		return sql;
	}
}





　　util




package com.ws.byd.bmgl.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;

import com.ws.byd.bmgl.bmzdpz.service.BmzdpzManager;
import com.ws.byd.common.dictionary.service.BydDicItemManager;
import com.ws.bzjggl.sjygl.service.SjyglManager;
import com.ws.core.db.AutoCachedb;
import com.ws.core.db.DataSourceFactory;
import com.ws.sys.core.utils.ServiceLocator;

public class BmzdCacheUtil {
	private static Logger logger = Logger.getLogger(BmzdCacheUtil.class);
	private static final BmzdCacheUtil instance = new BmzdCacheUtil();
	Map<String,String> zdxMap = new HashMap<String,String>();
	
	
	private BmzdCacheUtil() {
		BmzdpzManager bmzdpzManager = 
				(BmzdpzManager) ServiceLocator.getInstance().getService(BmzdpzManager.class);
		logger.info("加载编码字典...");
		this.zdxMap = bmzdpzManager.getBmzdpzZdx();
		logger.info("编码字典加载完成....");
	}
	
	public static BmzdCacheUtil getInstance() {
		return instance;
	}
	
	public String getBmzdCacheZdx(String id) {
		String name = "";
		String[] ids = id.split(",");
		if(ids.length > 0) {
			for(String str:ids) {
				if(!"*".equals(str)) {
				  name += zdxMap.get(str)+",";
				}else {
				  name += "*,";
				}
			}
			name = name.substring(0, name.length()-1);
		}
		return name;
	}
	
	public void flushBmzdCache() {
		BmzdpzManager bmzdpzManager = 
				(BmzdpzManager) ServiceLocator.getInstance().getService(BmzdpzManager.class);   //通过反射获取类里面的方法
		this.zdxMap = bmzdpzManager.getBmzdpzZdx();
	}
}





　　


 


interface SqlExecuteManager




package com.ws.db.service;

import java.util.List;

import org.apache.ibatis.session.SqlSessionFactory;

import com.ws.core.web.utils.FalsePager;
import com.ws.core.web.utils.Pager;
import com.ws.db.modle.SqlBuilder;
import com.ws.db.modle.TableOptionBuilder;

public interface SqlExecuteManager
{
    public <T> T getResultOne(SqlBuilder sqlBuilder,
            SqlSessionFactory sqlSessionFactory);
    public <T> T callProcedure(SqlBuilder sqlBuilder,
            SqlSessionFactory sqlSessionFactory);
    public <T> List<T> getResultList(SqlBuilder sqlBuilder,
            SqlSessionFactory sqlSessionFactory);
    public int insert(SqlBuilder sqlBuilder, SqlSessionFactory sqlSessionFactory);

    public int delete(SqlBuilder sqlBuilder,  SqlSessionFactory sqlSessionFactory);

    public int update(SqlBuilder sqlBuilder,  SqlSessionFactory sqlSessionFactory);
    
    public int insertBath(SqlBuilder sqlBuilder,  SqlSessionFactory sqlSessionFactory);
   
    public <T> T QueryAndOperation(SqlBuilder sqlBuilder,
            SqlSessionFactory sqlSessionFactory,QueryResultHandle<T> queryResultHandle);
	boolean createTable(TableOptionBuilder tableOptionBuilder,
			SqlSessionFactory sqlSessionFactory);
	/*****
	 * 假分页获取查询结果集
	 * @param <T>
	 * @param sqlBuilder 
	 * @param sqlSessionFactory
	 * @param page 页码
	 * @return
	 */
	   public <T> FalsePager<T> getResultFalsePager(SqlBuilder sqlBuilder,
	            SqlSessionFactory sqlSessionFactory, int page);
	  /*****
	   * 假分页获取查询结果集
	   * @param <T>
	   * @param sqlBuilder
	   * @param sqlSessionFactory
	   * @param page页码
	   * @param row 每页记录数
	   * @return
	   */
	public <T> FalsePager<T> getResultFalsePager(SqlBuilder sqlBuilder,
			SqlSessionFactory sqlSessionFactory, int page, int row);
	/******
	 * 统计符合条件的资源总数，多和假分页配套使用
	 * @param sqlBuilder
	 * @param sqlSessionFactory
	 * @return
	 */
	int getFalseResultCount(SqlBuilder sqlBuilder,
			SqlSessionFactory sqlSessionFactory);
	/****
	 * 假分页  替换 sql语句中的排序字段，要求sql语句中必须要有order by且必须后面跟有asc或者desc,否则会替换出错
	 * 可以单独指定排序字段，用于需要在列表点击属性进行排序
	 * @param <T>
	 * @param sqlBuilder
	 * @param sqlSessionFactory
	 * @param page 页码
	 * @param row 每页记录数
	 * @param sort 排序字段  新指定的排序字段，多个字段以逗号分隔，如果不指定排序规则，则默认为降序排序；
	 * @return
	 */
	public <T> FalsePager<T> getResultFalsePager(SqlBuilder sqlBuilder,
			SqlSessionFactory sqlSessionFactory, int page, int row, String sort);
	/****
	 * 假分页  替换 sql语句中的排序字段，要求sql语句中必须要有order by且必须后面跟有asc或者desc,否则会替换出错
	 * 可以单独指定排序字段，用于需要在列表点击属性进行排序
	 * @param <T>
	 * @param sqlBuilder
	 * @param sqlSessionFactory
	 * @param page 页码
	 * @param sort 排序字段 新指定的排序字段，多个字段以逗号分隔，如果不指定排序规则，则默认为降序排序；
	 * @return
	 */
	public <T> FalsePager<T> getResultFalsePager(SqlBuilder sqlBuilder,
			SqlSessionFactory sqlSessionFactory, int page, String sort);
	 /******
     * 真分页 默认每页展示10条记录
     * @param <T>
     * @param sqlBuilder
     * @param sqlSessionFactory
     * @param page
     * @return
     */
    public <T> Pager<T> getResultPager(SqlBuilder sqlBuilder,
            SqlSessionFactory sqlSessionFactory, int page);
    /*****
     * 真分页 需要指定每页展示的记录数
     * @param <T>
     * @param sqlBuilder
     * @param sqlSessionFactory
     * @param page 页码
     * @param row 每页展示的记录数
     * @return
     */
    public <T> Pager<T> getResultPager(SqlBuilder sqlBuilder,
            SqlSessionFactory sqlSessionFactory, int page, int row);
	/*****
	 * 真分页 需要指定排序字段  替换 sql语句中的排序字段，要求sql语句中必须要有order by且必须后面跟有asc或者desc,否则会替换出错
	 * @param <T>
	 * @param sqlBuilder
	 * @param sqlSessionFactory
	 * @param page 页码
	 * @param row 每页展示的记录条数
	 * @param sort 排序字段  新指定的排序字段，多个字段以逗号分隔，如果不指定排序规则，则默认为降序排序；
	 * @return
	 */
	public <T>  Pager<T> getResultPager(SqlBuilder sqlBuilder,
			SqlSessionFactory sqlSessionFactory, int page, int row, String sort);
	/*****
	 * 真分页 需要指定排序字段 不需要指定每页展示的记录数 替换 sql语句中的排序字段，要求sql语句中必须要有order by且必须后面跟有asc或者desc,否则会替换出错
	 * @param <T>
	 * @param sqlBuilder
	 * @param sqlSessionFactory
	 * @param page 页码
	 * @param sort  排序字段  新指定的排序字段，多个字段以逗号分隔，如果不指定排序规则，则默认为降序排序；
	 * @return
	 */
	public <T>  Pager<T> getResultPager(SqlBuilder sqlBuilder,
			SqlSessionFactory sqlSessionFactory, int page, String sort);
}





　　


 


 


============================================================================================================


Autowired注解


Resource注解


    

  1. @Resource注解和@Autowired注解都可以用作bean的注入.
    2. 

  2. 在接口只有一个实现类的时候,两个注解可以互相替换,效果相同.
    3. 



　　@Resource注解是Java自身的注解,@Autowired注解是Spring的注解.
　　@Resource注解有两个重要的属性,分别是name和type,如果name属性有值,则使用byName的自动注入策略,将值作为需要注入bean的名字,如果type有值,则使用byType自动注入策略,将值作为需要注入bean的类型.如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。即@Resource注解默认按照名称进行匹配,名称可以通过name属性进行指定，如果没有指定name属性，当注解写在字段上时，默认取字段名，按照名称查找,当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。
　　@Autowired注解是spring的注解,此注解只根据type进行注入,不会去匹配name.但是如果只根据type无法辨别注入对象时,就需要配合使用@Qualifier注解或者@Primary注解使用. 


总结


一个接口，俩个实现类（impl），Autowired就不知道注入哪一个实现类(得与@Qualifier（指定我要注入哪一个类）注解搭配使用才知道)，而Resource有name属性，可以区分要注入哪一个实现类。