随笔 - 56,  文章 - 11,  评论 - 0,  阅读 - 10008
package com.ws.byd.bmgl.bmzdpz:编码字典------bydobject
?
1
 
?
1
controller:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
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));
    }
     
}

　　

?
1
<br><br>
?
1
service:interface BmzdpzManager----》
?
1
BmzdpzManagerImpl implements BmzdpzManager-------》
?
1
BmzdpzSql

 

 

接口

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
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;
    }
 
}

　　

?
1
BmzdpzSql
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
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. 在接口只有一个实现类的时候,两个注解可以互相替换,效果相同.

　　@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属性，可以区分要注入哪一个实现类。

posted on   初晓臻  阅读(20)  评论(0)  编辑  收藏  举报
相关博文：
· org.apache.log4j.Logger
· springCRUDWeb项目创建录（maven）
· populateBean方法解析
· Spring系列-3.3 AutowiredAnnotationBeanPostProcessor
· Spring学习笔记 - 第二章 - 注解开发、配置管理第三方Bean、注解管理第三方Bean、Spring 整合 MyBatis 和 Junit 案例
阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？
Copyright © 2025 初晓臻
Powered by .NET 9.0 on Kubernetes Powered By: 博客园
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛