在未分享整个查询分页的执行代码之前，先了解一下执行流程。
1.总体上是利用mybatis的插件拦截器，在sql执行之前拦截，为查询语句加上limit X X
2.用一个Page对象，贯穿整个执行流程，这个Page对象需要用Java编写前端分页组件
3.用一套比较完整的三层entity，dao，service支持这个分页架构
4.这个分页用到的一些辅助类
注：分享的内容较多，这边的话我就不把需要的jar一一列举，大家使用这个分页功能的时候缺少什么就去晚上找什么jar包即可，尽可能用maven包导入因为maven能减少版本冲突等比较好的优势。
我只能说尽可能让大家快速使用这个比较好用的分页功能，如果讲得不明白，欢迎加我QQ一起探讨1063150576,。莫喷哈！还有就是文章篇幅可能会比较大，不过花点时间，把它看完并实践一下一定会收获良多。
第一步：既然主题是围绕怎么进行分页的，我们就从mybatis入手，首先，我们把mybatis相关的两个比较重要的配置文件拿出来做简要的理解，一个是mybatis-config.xml，另外一个是实体所对应的mapper配置文件，我会在配置文件上写好注释，大家一看就会明白。
mybatis-config.xml
|
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
|
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <!-- 全局参数 --> <settings> <!-- 使全局的映射器启用或禁用缓存。 --> <setting name="cacheEnabled" value="false"/> <!-- 全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载。 --> <setting name="lazyLoadingEnabled" value="true"/> <!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。否则，每种属性将会按需要加载。 --> <setting name="aggressiveLazyLoading" value="true"/> <!-- 是否允许单条sql 返回多个数据集 (取决于驱动的兼容性) default:true --> <setting name="multipleResultSetsEnabled" value="true"/> <!-- 是否可以使用列的别名 (取决于驱动的兼容性) default:true --> <setting name="useColumnLabel" value="true"/> <!-- 允许JDBC 生成主键。需要驱动器支持。如果设为了true，这个设置将强制使用被生成的主键，有一些驱动器不兼容不过仍然可以执行。 default:false --> <setting name="useGeneratedKeys" value="false"/> <!-- 指定 MyBatis 如何自动映射 数据基表的列 NONE：不隐射 PARTIAL:部分 FULL:全部 --> <setting name="autoMappingBehavior" value="PARTIAL"/> <!-- 这是默认的执行类型 （SIMPLE: 简单； REUSE: 执行器可能重复使用prepared statements语句；BATCH: 执行器可以重复执行语句和批量更新） --> <setting name="defaultExecutorType" value="SIMPLE"/> <!-- 使用驼峰命名法转换字段。 --> <setting name="mapUnderscoreToCamelCase" value="true"/> <!-- 设置本地缓存范围 session:就会有数据的共享 statement:语句范围 (这样就不会有数据的共享 ) defalut:session --> <setting name="localCacheScope" value="SESSION"/> <!-- 设置但JDBC类型为空时,某些驱动程序 要指定值,default:OTHER，插入空值时不需要指定类型 --> <setting name="jdbcTypeForNull" value="NULL"/> <setting name="logPrefix" value="dao."/> </settings> <!--别名是一个较短的Java 类型的名称 --> <typeAliases> <typeAlias type="com.store.base.model.StoreUser"alias="User"></typeAlias> <typeAlias type="com.store.base.secondmodel.pratice.model.Product"alias="Product"></typeAlias> <typeAlias type="com.store.base.secondmodel.base.Page"alias="Page"></typeAlias> </typeAliases> <!-- 插件配置,这边为mybatis配置分页拦截器，这个分页拦截器需要我们自己实现 --> <plugins> <plugin interceptor="com.store.base.secondmodel.base.pageinterceptor.PaginationInterceptor" /> </plugins> </configuration> |
一个ProductMapper.xml作为测试对象，这个mapper文件就简单配置一个需要用到的查询语句
|
1
2
3
4
5
6
7
8
9
10
|
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace="com.store.base.secondmodel.pratice.dao.ProductDao" > <sql id="baseColumns" > id, product_name as productName, product_no as productNo, price as price </sql> <select id="findList" resultType="com.store.base.secondmodel.pratice.model.Product"> select <include refid="baseColumns"/> from t_store_product </select> </mapper> |
第二步：接下去主要针对这个分页拦截器进行深入分析学习，主要有以下几个类和其对应接口
（1）BaseInterceptor 拦截器基础类
（2）PaginationInterceptor 我们要使用的分页插件类，继承上面基础类
（3）SQLHelper 主要是用来提前执行count语句，还有就是获取整个完整的分页语句
（4）Dialect，MysqlDialect,主要用来数据库是否支持limit语句，然后封装完整limit语句
以下是这几个类的分享展示
BaseInterceptor.java
|
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
|
package com.store.base.secondmodel.base.pageinterceptor; import java.io.Serializable; import java.util.Properties; import org.apache.ibatis.logging.Log; import org.apache.ibatis.logging.LogFactory; import org.apache.ibatis.plugin.Interceptor; import com.store.base.secondmodel.base.Global; import com.store.base.secondmodel.base.Page; import com.store.base.secondmodel.base.dialect.Dialect; import com.store.base.secondmodel.base.dialect.MySQLDialect; import com.store.base.util.Reflections; /** * Mybatis分页拦截器基类 * @author yiyong_wu * */public abstract class BaseInterceptor implements Interceptor, Serializable { private static final long serialVersionUID = 1L; protected static final String PAGE = "page"; protected static final String DELEGATE = "delegate"; protected static final String MAPPED_STATEMENT = "mappedStatement"; protected Log log = LogFactory.getLog(this.getClass()); protected Dialect DIALECT; /** * 对参数进行转换和检查 * @param parameterObject 参数对象 * @param page 分页对象 * @return 分页对象 * @throws NoSuchFieldException 无法找到参数 */@SuppressWarnings("unchecked") protected static Page<Object> convertParameter(Object parameterObject, Page<Object> page) { try{ if (parameterObject instanceof Page) { return (Page<Object>) parameterObject; } else { return (Page<Object>)Reflections.getFieldValue(parameterObject, PAGE); } }catch (Exception e) { return null; } } /** * 设置属性，支持自定义方言类和制定数据库的方式 * <code>dialectClass</code>,自定义方言类。可以不配置这项 * <ode>dbms</ode> 数据库类型，插件支持的数据库 * <code>sqlPattern</code> 需要拦截的SQL ID * @param p 属性 */protected void initProperties(Properties p) { Dialect dialect = null; String dbType = Global.getConfig("jdbc.type"); if("mysql".equals(dbType)){ dialect = new MySQLDialect(); } if (dialect == null) { throw new RuntimeException("mybatis dialect error."); } DIALECT = dialect; } } |
PaginationInterceptor.java
|
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
|
package com.store.base.secondmodel.base.pageinterceptor; import java.util.Properties; import org.apache.ibatis.executor.Executor; import org.apache.ibatis.mapping.BoundSql; import org.apache.ibatis.mapping.MappedStatement; import org.apache.ibatis.mapping.SqlSource; import org.apache.ibatis.plugin.Intercepts; import org.apache.ibatis.plugin.Invocation; import org.apache.ibatis.plugin.Plugin; import org.apache.ibatis.plugin.Signature; import org.apache.ibatis.reflection.MetaObject; import org.apache.ibatis.session.ResultHandler; import org.apache.ibatis.session.RowBounds; import com.store.base.secondmodel.base.Page; import com.store.base.secondmodel.base.util.StringUtils; import com.store.base.util.Reflections; /** * 数据库分页插件，只拦截查询语句. * @author yiyong_wu * */@Intercepts({ @Signature(type = Executor.class, method = "query", args = { MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class }) }) public class PaginationInterceptor extends BaseInterceptor { private static final long serialVersionUID = 1L; @Overridepublic Object intercept(Invocation invocation) throws Throwable { final MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0]; Object parameter = invocation.getArgs()[1]; BoundSql boundSql = mappedStatement.getBoundSql(parameter); Object parameterObject = boundSql.getParameterObject(); // 获取分页参数对象 Page<Object> page = null; if (parameterObject != null) { page = convertParameter(parameterObject, page); } // 如果设置了分页对象，则进行分页 if (page != null && page.getPageSize() != -1) { if (StringUtils.isBlank(boundSql.getSql())) { return null; } String originalSql = boundSql.getSql().trim(); // 得到总记录数 page.setCount(SQLHelper.getCount(originalSql, null,mappedStatement, parameterObject, boundSql, log)); // 分页查询 本地化对象 修改数据库注意修改实现 String pageSql = SQLHelper.generatePageSql(originalSql, page,DIALECT); invocation.getArgs()[2] = new RowBounds(RowBounds.NO_ROW_OFFSET,RowBounds.NO_ROW_LIMIT); BoundSql newBoundSql = new BoundSql( mappedStatement.getConfiguration(), pageSql, boundSql.getParameterMappings(), boundSql.getParameterObject()); // 解决MyBatis 分页foreach 参数失效 start if (Reflections.getFieldValue(boundSql, "metaParameters") != null) { MetaObject mo = (MetaObject) Reflections.getFieldValue( boundSql, "metaParameters"); Reflections.setFieldValue(newBoundSql, "metaParameters", mo); } // 解决MyBatis 分页foreach 参数失效 end MappedStatement newMs = copyFromMappedStatement(mappedStatement,new BoundSqlSqlSource(newBoundSql)); invocation.getArgs()[0] = newMs; } return invocation.proceed(); } @Overridepublic Object plugin(Object target) { return Plugin.wrap(target, this); } @Overridepublic void setProperties(Properties properties) { super.initProperties(properties); } private MappedStatement copyFromMappedStatement(MappedStatement ms, SqlSource newSqlSource) { MappedStatement.Builder builder = new MappedStatement.Builder( ms.getConfiguration(), ms.getId(), newSqlSource, ms.getSqlCommandType()); builder.resource(ms.getResource()); builder.fetchSize(ms.getFetchSize()); builder.statementType(ms.getStatementType()); builder.keyGenerator(ms.getKeyGenerator()); if (ms.getKeyProperties() != null) { for (String keyProperty : ms.getKeyProperties()) { builder.keyProperty(keyProperty); } } builder.timeout(ms.getTimeout()); builder.parameterMap(ms.getParameterMap()); builder.resultMaps(ms.getResultMaps()); builder.cache(ms.getCache()); return builder.build(); } public static class BoundSqlSqlSource implements SqlSource { BoundSql boundSql; public BoundSqlSqlSource(BoundSql boundSql) { this.boundSql = boundSql; } @Overridepublic BoundSql getBoundSql(Object parameterObject) { return boundSql; } } } |
SQLHelper.java
|
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
package com.store.base.secondmodel.base.pageinterceptor; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.ibatis.executor.ErrorContext; import org.apache.ibatis.executor.ExecutorException; import org.apache.ibatis.logging.Log; import org.apache.ibatis.mapping.BoundSql; import org.apache.ibatis.mapping.MappedStatement; import org.apache.ibatis.mapping.ParameterMapping; import org.apache.ibatis.mapping.ParameterMode; import org.apache.ibatis.reflection.MetaObject; import org.apache.ibatis.reflection.property.PropertyTokenizer; import org.apache.ibatis.scripting.xmltags.ForEachSqlNode; import org.apache.ibatis.session.Configuration; import org.apache.ibatis.type.TypeHandler; import org.apache.ibatis.type.TypeHandlerRegistry; import com.store.base.secondmodel.base.Global; import com.store.base.secondmodel.base.Page; import com.store.base.secondmodel.base.dialect.Dialect; import com.store.base.secondmodel.base.util.StringUtils; import com.store.base.util.Reflections; /** * SQL工具类 * @author yiyong_wu * */public class SQLHelper { /** * 默认私有构造函数 */private SQLHelper() { } /** * 对SQL参数(?)设值,参考org.apache.ibatis.executor.parameter.DefaultParameterHandler * * @param ps 表示预编译的 SQL 语句的对象。 * @param mappedStatement MappedStatement * @param boundSql SQL * @param parameterObject 参数对象 * @throws java.sql.SQLException 数据库异常 */@SuppressWarnings("unchecked") public static void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql, Object parameterObject) throws SQLException { ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId()); List<ParameterMapping> parameterMappings = boundSql.getParameterMappings(); if (parameterMappings != null) { Configuration configuration = mappedStatement.getConfiguration(); TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry(); MetaObject metaObject = parameterObject == null ? null : configuration.newMetaObject(parameterObject); for (int i = 0; i < parameterMappings.size(); i++) { ParameterMapping parameterMapping = parameterMappings.get(i); if (parameterMapping.getMode() != ParameterMode.OUT) { Object value; String propertyName = parameterMapping.getProperty(); PropertyTokenizer prop = new PropertyTokenizer(propertyName); if (parameterObject == null) { value = null; } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) { value = parameterObject; } else if (boundSql.hasAdditionalParameter(propertyName)) { value = boundSql.getAdditionalParameter(propertyName); } else if (propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX) && boundSql.hasAdditionalParameter(prop.getName())) { value = boundSql.getAdditionalParameter(prop.getName()); if (value != null) { value = configuration.newMetaObject(value).getValue(propertyName.substring(prop.getName().length())); } } else { value = metaObject == null ? null : metaObject.getValue(propertyName); } @SuppressWarnings("rawtypes") TypeHandler typeHandler = parameterMapping.getTypeHandler(); if (typeHandler == null) { throw new ExecutorException("There was no TypeHandler found for parameter " + propertyName + " of statement " + mappedStatement.getId()); } typeHandler.setParameter(ps, i + 1, value, parameterMapping.getJdbcType()); } } } } /** * 查询总纪录数 * @param sql SQL语句 * @param connection 数据库连接 * @param mappedStatement mapped * @param parameterObject 参数 * @param boundSql boundSql * @return 总记录数 * @throws SQLException sql查询错误 */public static int getCount(final String sql, final Connection connection, final MappedStatement mappedStatement, final Object parameterObject, final BoundSql boundSql, Log log) throws SQLException { String dbName = Global.getConfig("jdbc.type"); final String countSql; if("oracle".equals(dbName)){ countSql = "select count(1) from (" + sql + ") tmp_count"; }else{ countSql = "select count(1) from (" + removeOrders(sql) + ") tmp_count"; } Connection conn = connection; PreparedStatement ps = null; ResultSet rs = null; try { if (log.isDebugEnabled()) { log.debug("COUNT SQL: " + StringUtils.replaceEach(countSql, new String[]{"\n","\t"}, new String[]{" "," "})); } if (conn == null){ conn = mappedStatement.getConfiguration().getEnvironment().getDataSource().getConnection(); } ps = conn.prepareStatement(countSql); BoundSql countBS = new BoundSql(mappedStatement.getConfiguration(), countSql, boundSql.getParameterMappings(), parameterObject); //解决MyBatis 分页foreach 参数失效 start if (Reflections.getFieldValue(boundSql, "metaParameters") != null) { MetaObject mo = (MetaObject) Reflections.getFieldValue(boundSql, "metaParameters"); Reflections.setFieldValue(countBS, "metaParameters", mo); } //解决MyBatis 分页foreach 参数失效 end SQLHelper.setParameters(ps, mappedStatement, countBS, parameterObject); rs = ps.executeQuery(); int count = 0; if (rs.next()) { count = rs.getInt(1); } return count; } finally { if (rs != null) { rs.close(); } if (ps != null) { ps.close(); } if (conn != null) { conn.close(); } } } /** * 根据数据库方言，生成特定的分页sql * @param sql Mapper中的Sql语句 * @param page 分页对象 * @param dialect 方言类型 * @return 分页SQL */public static String generatePageSql(String sql, Page<Object> page, Dialect dialect) { if (dialect.supportsLimit()) { return dialect.getLimitString(sql, page.getFirstResult(), page.getMaxResults()); } else { return sql; } } /** * 去除qlString的select子句。 * @param hql * @return */@SuppressWarnings("unused") private static String removeSelect(String qlString){ int beginPos = qlString.toLowerCase().indexOf("from"); return qlString.substring(beginPos); } /** * 去除hql的orderBy子句。 * @param hql * @return */private static String removeOrders(String qlString) { Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*", Pattern.CASE_INSENSITIVE); Matcher m = p.matcher(qlString); StringBuffer sb = new StringBuffer(); while (m.find()) { m.appendReplacement(sb, ""); } m.appendTail(sb); return sb.toString(); } } |
Dialect.java 接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package com.store.base.secondmodel.base.dialect; /** * 类似hibernate的Dialect,但只精简出分页部分 * @author yiyong_wu * */public interface Dialect { /** * 数据库本身是否支持分页当前的分页查询方式 * 如果数据库不支持的话，则不进行数据库分页 * * @return true：支持当前的分页查询方式 */public boolean supportsLimit(); /** * 将sql转换为分页SQL，分别调用分页sql * * @param sql SQL语句 * @param offset 开始条数 * @param limit 每页显示多少纪录条数 * @return 分页查询的sql */public String getLimitString(String sql, int offset, int limit); } |
MySQLDialect.java
|
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
|
package com.store.base.secondmodel.base.dialect; /** * Mysql方言的实现 * @author yiyong_wu * */public class MySQLDialect implements Dialect { @Overridepublic boolean supportsLimit() { return true; } @Overridepublic String getLimitString(String sql, int offset, int limit) { return getLimitString(sql, offset, Integer.toString(offset),Integer.toString(limit)); } /** * 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换. * <pre> * 如mysql * dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回 * select * from user limit :offset,:limit * </pre> * * @param sql 实际SQL语句 * @param offset 分页开始纪录条数 * @param offsetPlaceholder 分页开始纪录条数－占位符号 * @param limitPlaceholder 分页纪录条数占位符号 * @return 包含占位符的分页sql */public String getLimitString(String sql, int offset, String offsetPlaceholder, String limitPlaceholder) { StringBuilder stringBuilder = new StringBuilder(sql); stringBuilder.append(" limit "); if (offset > 0) { stringBuilder.append(offsetPlaceholder).append(",").append(limitPlaceholder); } else { stringBuilder.append(limitPlaceholder); } return stringBuilder.toString(); } } |
差不多到这边已经把整块分页怎么实现的给分享完了，但是我们还有更重要的任务，想要整个东西跑起来，肯定还要有基础工作要做，接下去我们分析整套Page对象以及它所依据的三层架构，还是用product作为实体进行分析。一整套三层架构讲下来，收获肯定又满满的。我们依次从entity->dao->service的顺序讲下来。
首先，针对我们的实体得继承两个抽象实体类BaseEntity 与 DataEntity
BaseEntity.java 主要放置Page成员变量，继承它后就可以每个实体都拥有这个成员变量
|
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
|
package com.store.base.secondmodel.base; import java.io.Serializable; import java.util.Map; import javax.xml.bind.annotation.XmlTransient; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.builder.ReflectionToStringBuilder; import com.fasterxml.jackson.annotation.JsonIgnore; import com.google.common.collect.Maps; import com.store.base.model.StoreUser; /** * 最顶层的Entity * @author yiyong_wu * * @param <T> */public abstract class BaseEntity<T> implements Serializable { private static final long serialVersionUID = 1L; /** * 删除标记（0：正常；1：删除；2：审核；） */public static final String DEL_FLAG_NORMAL = "0"; public static final String DEL_FLAG_DELETE = "1"; public static final String DEL_FLAG_AUDIT = "2"; /** * 实体编号（唯一标识） */protected String id; /** * 当前用户 */protected StoreUser currentUser; /** * 当前实体分页对象 */protected Page<T> page; /** * 自定义SQL（SQL标识，SQL内容） */private Map<String, String> sqlMap; public BaseEntity() { } public BaseEntity(String id) { this(); this.id = id; } public String getId() { return id; } public void setId(String id) { this.id = id; } /** * 这个主要针对shiro执行插入更新的时候会调用，获取当前的用户 * @return */@JsonIgnore@XmlTransientpublic StoreUser getCurrentUser() { if(currentUser == null){ // currentUser = UserUtils.getUser(); } return currentUser; } public void setCurrentUser(StoreUser currentUser) { this.currentUser = currentUser; } @JsonIgnore@XmlTransientpublic Page<T> getPage() { if (page == null){ page = new Page<>(); } return page; } public Page<T> setPage(Page<T> page) { this.page = page; return page; } @JsonIgnore@XmlTransientpublic Map<String, String> getSqlMap() { if (sqlMap == null){ sqlMap = Maps.newHashMap(); } return sqlMap; } public void setSqlMap(Map<String, String> sqlMap) { this.sqlMap = sqlMap; } /** * 插入之前执行方法，子类实现 */public abstract void preInsert(); /** * 更新之前执行方法，子类实现 */public abstract void preUpdate(); /** * 是否是新记录（默认：false），调用setIsNewRecord()设置新记录，使用自定义ID。 * 设置为true后强制执行插入语句，ID不会自动生成，需从手动传入。 * @return */public boolean getIsNewRecord() { return StringUtils.isBlank(getId()); } /** * 全局变量对象 */@JsonIgnorepublic Global getGlobal() { return Global.getInstance(); } /** * 获取数据库名称 */@JsonIgnorepublic String getDbName(){ return Global.getConfig("jdbc.type"); } @Overridepublic String toString() { return ReflectionToStringBuilder.toString(this); } } |
DataEntity.java,主要存储更新删除时间，创建用户，更新用户，逻辑删除标志等
|
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
|
package com.store.base.secondmodel.base; import java.util.Date; import org.hibernate.validator.constraints.Length; import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonIgnore; import com.store.base.model.StoreUser; /** * 数据Entity * @author yiyong_wu * * @param <T> */public abstract class DataEntity<T> extends BaseEntity<T> { private static final long serialVersionUID = 1L; protected StoreUser createBy; // 创建者 protected Date createDate; // 创建日期 protected StoreUser updateBy; // 更新者 protected Date updateDate; // 更新日期 protected String delFlag; // 删除标记（0：正常；1：删除；2：审核） public DataEntity() { super(); this.delFlag = DEL_FLAG_NORMAL; } public DataEntity(String id) { super(id); } /** * 插入之前执行方法，需要手动调用 */@Overridepublic void preInsert() { // 不限制ID为UUID，调用setIsNewRecord()使用自定义ID // User user = UserUtils.getUser(); // if (StringUtils.isNotBlank(user.getId())) { // this.updateBy = user; // this.createBy = user; // } this.updateDate = new Date(); this.createDate = this.updateDate; } /** * 更新之前执行方法，需要手动调用 */@Overridepublic void preUpdate() { // User user = UserUtils.getUser(); // if (StringUtils.isNotBlank(user.getId())) { // this.updateBy = user; // } this.updateDate = new Date(); } // @JsonIgnore public StoreUser getCreateBy() { return createBy; } public void setCreateBy(StoreUser createBy) { this.createBy = createBy; } @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") public Date getCreateDate() { return createDate; } public void setCreateDate(Date createDate) { this.createDate = createDate; } // @JsonIgnore public StoreUser getUpdateBy() { return updateBy; } public void setUpdateBy(StoreUser updateBy) { this.updateBy = updateBy; } @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") public Date getUpdateDate() { return updateDate; } public void setUpdateDate(Date updateDate) { this.updateDate = updateDate; } @JsonIgnore@Length(min = 1, max = 1) public String getDelFlag() { return delFlag; } public void setDelFlag(String delFlag) { this.delFlag = delFlag; } } |
Product.java 产品类
|
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
|
package com.store.base.secondmodel.pratice.model; import com.store.base.secondmodel.base.DataEntity; /** *产品基础类 *2016年10月11日 *yiyong_wu */public class Product extends DataEntity<Product>{ private static final long serialVersionUID = 1L; private String productName; private float price; private String productNo; public String getProductName() { return productName; } public void setProductName(String productName) { this.productName = productName; } public float getPrice() { return price; } public void setPrice(float price) { this.price = price; } public String getProductNo() { return productNo; } public void setProductNo(String productNo) { this.productNo = productNo; } } |
怎么样，是不是看到很复杂的一个实体继承连关系，不过这有什么，越复杂就会越完整。接下来我就看看dao层，同样是三层，准备好接受洗礼吧
BaseDao.java 预留接口
|
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
|
package com.store.base.secondmodel.base; /** * 最顶层的DAO接口 * @author yiyong_wu * */public interface BaseDao { } CrudDao.java 针对增删改查的一个dao接口层[java] view plain copy print?在CODE上查看代码片派生到我的代码片package com.store.base.secondmodel.base; import java.util.List; /** * 定义增删改查的DAO接口 * @author yiyong_wu * * @param <T> */public interface CrudDao<T> extends BaseDao { /** * 获取单条数据 * @param id * @return */public T get(String id); /** * 获取单条数据 * @param entity * @return */public T get(T entity); /** * 查询数据列表，如果需要分页，请设置分页对象，如：entity.setPage(new Page<T>()); * @param entity * @return */public List<T> findList(T entity); /** * 查询所有数据列表 * @param entity * @return */public List<T> findAllList(T entity); /** * 查询所有数据列表 * @see public List<T> findAllList(T entity) * @return public List<T> findAllList(); *//** * 插入数据 * @param entity * @return */public int insert(T entity); /** * 更新数据 * @param entity * @return */public int update(T entity); /** * 删除数据（一般为逻辑删除，更新del_flag字段为1） * @param id * @see public int delete(T entity) * @return */public int delete(String id); /** * 删除数据（一般为逻辑删除，更新del_flag字段为1） * @param entity * @return */public int delete(T entity); } |
ProductDao.java mybatis对应的接口mapper，同时也是dao实现，这边需要自定一个注解@MyBatisRepository
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package com.store.base.secondmodel.pratice.dao; import com.store.base.secondmodel.base.CrudDao; import com.store.base.secondmodel.base.MyBatisRepository; import com.store.base.secondmodel.pratice.model.Product; /** *TODO *2016年10月11日 *yiyong_wu */@MyBatisRepositorypublic interface ProductDao extends CrudDao<Product>{ } |
自定义注解MyBatisRepository.java，跟自定义注解相关，这里就不做过多的解读，网上资料一堆
|
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
|
package com.store.base.secondmodel.base; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.Target; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.ElementType; import org.springframework.stereotype.Component; /** * 标识MyBatis的DAO,方便{@link org.mybatis.spring.mapper.MapperScannerConfigurer}的扫描。 * * 请注意要在spring的配置文件中配置扫描该注解类的配置 * *<bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer"> *<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" /> *<property name="basePackage" value="com.store.base.secondmodel" /> *<property name="annotationClass" value="com.store.base.secondmodel.base.MyBatisRepository" /> *</bean> * @author yiyong_wu * */@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Documented@Componentpublic @interface MyBatisRepository { String value() default ""; } |
注意：跟ProductDao.java联系比较大的是ProductMapper.xml文件，大家可以看到上面那个配置文件的namespace是指向这个dao的路径的。
接下来我们就进入最后的service分析了，一样还是三层继承
BaseService.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package com.store.base.secondmodel.base; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.transaction.annotation.Transactional; /** * Service的最顶层父类 * @author yiyong_wu * */@Transactional(readOnly = true) public abstract class BaseService { //日志记录用的 protected Logger logger = LoggerFactory.getLogger(getClass()); } |
CrudService.java 增删改查相关的业务接口实现
|
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
|
package com.store.base.secondmodel.base; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.transaction.annotation.Transactional; /** * 增删改查Service基类 * @author yiyong_wu * * @param <D> * @param <T> */public abstract class CrudService<D extends CrudDao<T>, T extends DataEntity<T>> extends BaseService { /** * 持久层对象 */@Autowiredprotected D dao; /** * 获取单条数据 * @param id * @return */public T get(String id) { return dao.get(id); } /** * 获取单条数据 * @param entity * @return */public T get(T entity) { return dao.get(entity); } /** * 查询列表数据 * @param entity * @return */public List<T> findList(T entity) { return dao.findList(entity); } /** * 查询分页数据 * @param page 分页对象 * @param entity * @return */public Page<T> findPage(Page<T> page, T entity) { entity.setPage(page); page.setList(dao.findList(entity)); return page; } /** * 保存数据（插入或更新） * @param entity */@Transactional(readOnly = false) public void save(T entity) { if (entity.getIsNewRecord()){ entity.preInsert(); dao.insert(entity); }else{ entity.preUpdate(); dao.update(entity); } } /** * 删除数据 * @param entity */@Transactional(readOnly = false) public void delete(T entity) { dao.delete(entity); } } |
ProductService.java,去继承CrudService接口，注意起注入dao和实体类型的一种模式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package com.store.base.secondmodel.pratice.service; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import com.store.base.secondmodel.base.CrudService; import com.store.base.secondmodel.pratice.dao.ProductDao; import com.store.base.secondmodel.pratice.model.Product; /** *TODO *2016年10月11日 *yiyong_wu */@Service@Transactional(readOnly = true) public class ProductService extends CrudService<ProductDao,Product>{ } |
我想看到这里的同志已经很不耐烦了。但是如果你错过接下去的一段，基本上刚才看的就快等于白看了，革命的胜利就在后半段，因为整个分页功能围绕的就是一个Page对象，重磅内容终于要出来了，当你把Page对象填充到刚才那个BaseEntity上的时候，你会发现一切就完整起来了，废话不多说，Page对象如下
|
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
|
package com.store.base.secondmodel.base; import java.io.Serializable; import java.util.ArrayList; import java.util.List; import java.util.regex.Pattern; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.fasterxml.jackson.annotation.JsonIgnore; import com.store.base.secondmodel.base.util.CookieUtils; import com.store.base.secondmodel.base.util.StringUtils; /** * 分页类 * @author yiyong_wu * * @param <T> */public class Page<T> implements Serializable{ private static final long serialVersionUID = 1L; private int pageNo = 1; // 当前页码 private int pageSize = Integer.parseInt(Global.getConfig("page.pageSize")); // 页面大小，设置为“-1”表示不进行分页（分页无效） private long count;// 总记录数，设置为“-1”表示不查询总数 private int first;// 首页索引 private int last;// 尾页索引 private int prev;// 上一页索引 private int next;// 下一页索引 private boolean firstPage;//是否是第一页 private boolean lastPage;//是否是最后一页 private int length = 6;// 显示页面长度 private int slider = 1;// 前后显示页面长度 private List<T> list = new ArrayList<>(); private String orderBy = ""; // 标准查询有效， 实例： updatedate desc, name asc private String funcName = "page"; // 设置点击页码调用的js函数名称，默认为page，在一页有多个分页对象时使用。 private String funcParam = ""; // 函数的附加参数，第三个参数值。 private String message = ""; // 设置提示消息，显示在“共n条”之后 public Page() { this.pageSize = -1; } /** * 构造方法 * @param request 传递 repage 参数，来记住页码 * @param response 用于设置 Cookie，记住页码 */public Page(HttpServletRequest request, HttpServletResponse response){ this(request, response, -2); } /** * 构造方法 * @param request 传递 repage 参数，来记住页码 * @param response 用于设置 Cookie，记住页码 * @param defaultPageSize 默认分页大小，如果传递 -1 则为不分页，返回所有数据 */public Page(HttpServletRequest request, HttpServletResponse response, int defaultPageSize){ // 设置页码参数（传递repage参数，来记住页码） String no = request.getParameter("pageNo"); if (StringUtils.isNumeric(no)){ CookieUtils.setCookie(response, "pageNo", no); this.setPageNo(Integer.parseInt(no)); }else if (request.getParameter("repage")!=null){ no = CookieUtils.getCookie(request, "pageNo"); if (StringUtils.isNumeric(no)){ this.setPageNo(Integer.parseInt(no)); } } // 设置页面大小参数（传递repage参数，来记住页码大小） String size = request.getParameter("pageSize"); if (StringUtils.isNumeric(size)){ CookieUtils.setCookie(response, "pageSize", size); this.setPageSize(Integer.parseInt(size)); }else if (request.getParameter("repage")!=null){ no = CookieUtils.getCookie(request, "pageSize"); if (StringUtils.isNumeric(size)){ this.setPageSize(Integer.parseInt(size)); } }else if (defaultPageSize != -2){ this.pageSize = defaultPageSize; } // 设置排序参数 String orderBy = request.getParameter("orderBy"); if (StringUtils.isNotBlank(orderBy)){ this.setOrderBy(orderBy); } } /** * 构造方法 * @param pageNo 当前页码 * @param pageSize 分页大小 */public Page(int pageNo, int pageSize) { this(pageNo, pageSize, 0); } /** * 构造方法 * @param pageNo 当前页码 * @param pageSize 分页大小 * @param count 数据条数 */public Page(int pageNo, int pageSize, long count) { this(pageNo, pageSize, count, new ArrayList<T>()); } /** * 构造方法 * @param pageNo 当前页码 * @param pageSize 分页大小 * @param count 数据条数 * @param list 本页数据对象列表 */public Page(int pageNo, int pageSize, long count, List<T> list) { this.setCount(count); this.setPageNo(pageNo); this.pageSize = pageSize; this.list = list; } /** * 初始化参数 */public void initialize(){ //1 this.first = 1; this.last = (int)(count / (this.pageSize < 1 ? 20 : this.pageSize) + first - 1); if (this.count % this.pageSize != 0 || this.last == 0) { this.last++; } if (this.last < this.first) { this.last = this.first; } if (this.pageNo <= 1) { this.pageNo = this.first; this.firstPage=true; } if (this.pageNo >= this.last) { this.pageNo = this.last; this.lastPage=true; } if (this.pageNo < this.last - 1) { this.next = this.pageNo + 1; } else { this.next = this.last; } if (this.pageNo > 1) { this.prev = this.pageNo - 1; } else { this.prev = this.first; } //2 if (this.pageNo < this.first) {// 如果当前页小于首页 this.pageNo = this.first; } if (this.pageNo > this.last) {// 如果当前页大于尾页 this.pageNo = this.last; } } /** * 默认输出当前分页标签 * <div class="page">${page}</div> */@Overridepublic String toString() { StringBuilder sb = new StringBuilder(); if (pageNo == first) {// 如果是首页 sb.append("<li class=\"disabled\"><a href=\"javascript:\">« 上一页</a></li>\n"); } else { sb.append("<li><a href=\"javascript:\" onclick=\""+funcName+"("+prev+","+pageSize+",'"+funcParam+"');\">« 上一页</a></li>\n"); } int begin = pageNo - (length / 2); if (begin < first) { begin = first; } int end = begin + length - 1; if (end >= last) { end = last; begin = end - length + 1; if (begin < first) { begin = first; } } if (begin > first) { int i = 0; for (i = first; i < first + slider && i < begin; i++) { sb.append("<li><a href=\"javascript:\" onclick=\""+funcName+"("+i+","+pageSize+",'"+funcParam+"');\">"+ (i + 1 - first) + "</a></li>\n"); } if (i < begin) { sb.append("<li class=\"disabled\"><a href=\"javascript:\">...</a></li>\n"); } } for (int i = begin; i <= end; i++) { if (i == pageNo) { sb.append("<li class=\"active\"><a href=\"javascript:\">" + (i + 1 - first) + "</a></li>\n"); } else { sb.append("<li><a href=\"javascript:\" onclick=\""+funcName+"("+i+","+pageSize+",'"+funcParam+"');\">"+ (i + 1 - first) + "</a></li>\n"); } } if (last - end > slider) { sb.append("<li class=\"disabled\"><a href=\"javascript:\">...</a></li>\n"); end = last - slider; } for (int i = end + 1; i <= last; i++) { sb.append("<li><a href=\"javascript:\" onclick=\""+funcName+"("+i+","+pageSize+",'"+funcParam+"');\">"+ (i + 1 - first) + "</a></li>\n"); } if (pageNo == last) { sb.append("<li class=\"disabled\"><a href=\"javascript:\">下一页 »</a></li>\n"); } else { sb.append("<li><a href=\"javascript:\" onclick=\""+funcName+"("+next+","+pageSize+",'"+funcParam+"');\">"+ "下一页 »</a></li>\n"); } return sb.toString(); } /** * 获取分页HTML代码 * @return */public String getHtml(){ return toString(); } /** * 获取设置总数 * @return */public long getCount() { return count; } /** * 设置数据总数 * @param count */public void setCount(long count) { this.count = count; if (pageSize >= count){ pageNo = 1; } } /** * 获取当前页码 * @return */public int getPageNo() { return pageNo; } /** * 设置当前页码 * @param pageNo */public void setPageNo(int pageNo) { this.pageNo = pageNo; } /** * 获取页面大小 * @return */public int getPageSize() { return pageSize; } /** * 设置页面大小（最大500）// > 500 ? 500 : pageSize; * @param pageSize */public void setPageSize(int pageSize) { this.pageSize = pageSize <= 0 ? 10 : pageSize; } /** * 首页索引 * @return */@JsonIgnorepublic int getFirst() { return first; } /** * 尾页索引 * @return */@JsonIgnorepublic int getLast() { return last; } /** * 获取页面总数 * @return getLast(); */@JsonIgnorepublic int getTotalPage() { return getLast(); } /** * 是否为第一页 * @return */@JsonIgnorepublic boolean isFirstPage() { return firstPage; } /** * 是否为最后一页 * @return */@JsonIgnorepublic boolean isLastPage() { return lastPage; } /** * 上一页索引值 * @return */@JsonIgnorepublic int getPrev() { if (isFirstPage()) { return pageNo; } else { return pageNo - 1; } } /** * 下一页索引值 * @return */@JsonIgnorepublic int getNext() { if (isLastPage()) { return pageNo; } else { return pageNo + 1; } } /** * 获取本页数据对象列表 * @return List<T> */public List<T> getList() { return list; } /** * 设置本页数据对象列表 * @param list */public Page<T> setList(List<T> list) { this.list = list; initialize(); return this; } /** * 获取查询排序字符串 * @return */@JsonIgnorepublic String getOrderBy() { // SQL过滤，防止注入 String reg = "(?:')|(?:--)|(/\\*(?:.|[\\n\\r])*?\\*/)|"+ "(\\b(select|update|and|or|delete|insert|trancate|char|into|substr|ascii|declare|exec|count|master|into|drop|execute)\\b)"; Pattern sqlPattern = Pattern.compile(reg, Pattern.CASE_INSENSITIVE); if (sqlPattern.matcher(orderBy).find()) { return ""; } return orderBy; } /** * 设置查询排序，标准查询有效， 实例： updatedate desc, name asc */public void setOrderBy(String orderBy) { this.orderBy = orderBy; } /** * 获取点击页码调用的js函数名称 * function ${page.funcName}(pageNo){location="${ctx}/list-${category.id}${urlSuffix}?pageNo="+i;} * @return */@JsonIgnorepublic String getFuncName() { return funcName; } /** * 设置点击页码调用的js函数名称，默认为page，在一页有多个分页对象时使用。 * @param funcName 默认为page */public void setFuncName(String funcName) { this.funcName = funcName; } /** * 获取分页函数的附加参数 * @return */@JsonIgnorepublic String getFuncParam() { return funcParam; } /** * 设置分页函数的附加参数 * @return */public void setFuncParam(String funcParam) { this.funcParam = funcParam; } /** * 设置提示消息，显示在“共n条”之后 * @param message */public void setMessage(String message) { this.message = message; } /** * 分页是否有效 * @return this.pageSize==-1 */@JsonIgnorepublic boolean isDisabled() { return this.pageSize==-1; } /** * 是否进行总数统计 * @return this.count==-1 */@JsonIgnorepublic boolean isNotCount() { return this.count==-1; } /** * 获取 Hibernate FirstResult */public int getFirstResult(){ int firstResult = (getPageNo() - 1) * getPageSize(); if (firstResult >= getCount()) { firstResult = 0; } return firstResult; } /** * 获取 Hibernate MaxResults */public int getMaxResults(){ return getPageSize(); } } |
看完这个Page对象应该稍微有点感觉了吧，然后我在胡乱贴一些相关用到的工具类吧，工具类的话我只稍微提一下，具体大家可以弄到自己的代码上好好解读。
PropertiesLoader.java 用来获取resource文件夹下的常量配置文件
|
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
|
package com.store.base.secondmodel.base.util; import java.io.IOException; import java.io.InputStream; import java.util.NoSuchElementException; import java.util.Properties; import org.apache.commons.io.IOUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.core.io.DefaultResourceLoader; import org.springframework.core.io.Resource; import org.springframework.core.io.ResourceLoader; /** * Properties文件载入工具类. 可载入多个properties文件, * 相同的属性在最后载入的文件中的值将会覆盖之前的值，但以System的Property优先. * @author yiyong_wu * */public class PropertiesLoader { private static Logger logger = LoggerFactory.getLogger(PropertiesLoader.class); private static ResourceLoader resourceLoader = new DefaultResourceLoader(); private final Properties properties; public PropertiesLoader(String... resourcesPaths) { properties = loadProperties(resourcesPaths); } public Properties getProperties() { return properties; } /** * 取出Property，但以System的Property优先,取不到返回空字符串. */private String getValue(String key) { String systemProperty = System.getProperty(key); if (systemProperty != null) { return systemProperty; } if (properties.containsKey(key)) { return properties.getProperty(key); } return ""; } /** * 取出String类型的Property，但以System的Property优先,如果都为Null则抛出异常. */public String getProperty(String key) { String value = getValue(key); if (value == null) { throw new NoSuchElementException(); } return value; } /** * 取出String类型的Property，但以System的Property优先.如果都为Null则返回Default值. */public String getProperty(String key, String defaultValue) { String value = getValue(key); return value != null ? value : defaultValue; } /** * 取出Integer类型的Property，但以System的Property优先.如果都为Null或内容错误则抛出异常. */public Integer getInteger(String key) { String value = getValue(key); if (value == null) { throw new NoSuchElementException(); } return Integer.valueOf(value); } /** * 取出Integer类型的Property，但以System的Property优先.如果都为Null则返回Default值，如果内容错误则抛出异常 */public Integer getInteger(String key, Integer defaultValue) { String value = getValue(key); return value != null ? Integer.valueOf(value) : defaultValue; } /** * 取出Double类型的Property，但以System的Property优先.如果都为Null或内容错误则抛出异常. */public Double getDouble(String key) { String value = getValue(key); if (value == null) { throw new NoSuchElementException(); } return Double.valueOf(value); } /** * 取出Double类型的Property，但以System的Property优先.如果都为Null则返回Default值，如果内容错误则抛出异常 */public Double getDouble(String key, Integer defaultValue) { String value = getValue(key); return value != null ? Double.valueOf(value) : defaultValue.doubleValue(); } /** * 取出Boolean类型的Property，但以System的Property优先.如果都为Null抛出异常,如果内容不是true/false则返回false. */public Boolean getBoolean(String key) { String value = getValue(key); if (value == null) { throw new NoSuchElementException(); } return Boolean.valueOf(value); } /** * 取出Boolean类型的Property，但以System的Property优先.如果都为Null则返回Default值,如果内容不为true/false则返回false. */public Boolean getBoolean(String key, boolean defaultValue) { String value = getValue(key); return value != null ? Boolean.valueOf(value) : defaultValue; } /** * 载入多个文件, 文件路径使用Spring Resource格式. */private Properties loadProperties(String... resourcesPaths) { Properties props = new Properties(); for (String location : resourcesPaths) { InputStream is = null; try { Resource resource = resourceLoader.getResource(location); is = resource.getInputStream(); props.load(is); } catch (IOException ex) { logger.error("Could not load properties from path:" + location , ex); } finally { IOUtils.closeQuietly(is); } } return props; } } |
Global.java 用来获取全局的一些常量，可以是从配置文件中读取的常量，也可以是定义成final static的常量，获取配置文件的话是调用上面那个类进行获取的。
|
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.store.base.secondmodel.base; import java.io.File; import java.io.IOException; import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.core.io.DefaultResourceLoader; import com.google.common.collect.Maps; import com.store.base.secondmodel.base.util.PropertiesLoader; import com.store.base.secondmodel.base.util.StringUtils; /** * 全局配置类 * @author yiyong_wu * */public class Global { private static final Logger logger = LoggerFactory.getLogger(Global.class); /** * 当前对象实例 */private static Global global = new Global(); /** * 保存全局属性值 */private static Map<String, String> map = Maps.newHashMap(); /** * 属性文件加载对象 */private static PropertiesLoader loader = new PropertiesLoader("application.properties"); /** * 显示/隐藏 public static final String SHOW = "1"; public static final String HIDE = "0"; /** * 是/否 */public static final String YES = "1"; public static final String NO = "0"; /** * 状态 上/下 app专用 */public static final String UPSHVELF = "1"; public static final String DOWNSHVELF = "2"; public static final String SEPARATOR = "/"; /** * 对/错 */public static final String TRUE = "true"; public static final String FALSE = "false"; /** * 上传文件基础虚拟路径 */public static final String USERFILES_BASE_URL = "/userfiles/"; /** * 针对富文本编辑器，结尾会产生的空div */public static final String ENDS = "<p><br></p>"; /** * 默认空的私有构造函数 */public Global() { //do nothing in this method,just empty } /** * 获取当前对象实例 */public static Global getInstance() { return global; } /** * 获取配置 */public static String getConfig(String key) { String value = map.get(key); if (value == null){ value = loader.getProperty(key); map.put(key, value != null ? value : StringUtils.EMPTY); } return value; } /** * 获取URL后缀 */public static String getUrlSuffix() { return getConfig("urlSuffix"); } /** * 页面获取常量 * @see ${fns:getConst('YES')} */public static Object getConst(String field) { try { return Global.class.getField(field).get(null); } catch (Exception e) { logger.error("获取常量出错", e); } return null; } /** * 获取工程路径 * @return */public static String getProjectPath(){ // 如果配置了工程路径，则直接返回，否则自动获取。 String projectPath = Global.getConfig("projectPath"); if (StringUtils.isNotBlank(projectPath)){ return projectPath; } try { File file = new DefaultResourceLoader().getResource("").getFile(); if (file != null){ while(true){ File f = new File(file.getPath() + File.separator + "src" + File.separator + "main"); if (f == null || f.exists()){ break; } if (file.getParentFile() != null){ file = file.getParentFile(); }else{ break; } } projectPath = file.toString(); } } catch (IOException e) { logger.error("加载配置文件失败", e); } return projectPath; } } |
CookieUtil.java 从名称就知道是针对获取和存储cookie的一个工具类
|
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
|
package com.store.base.secondmodel.base.util; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.net.URLEncoder; import javax.servlet.http.Cookie; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Cookie工具类 * @author yiyong_wu * */public class CookieUtils { private static final Logger logger = LoggerFactory.getLogger(CookieUtils.class); /** * 私有构造函数 */private CookieUtils() { } /** * 设置 Cookie（生成时间为1年） * @param name 名称 * @param value 值 */public static void setCookie(HttpServletResponse response, String name, String value) { setCookie(response, name, value, 60*60*24*365); } /** * 设置 Cookie * @param name 名称 * @param value 值 * @param maxAge 生存时间（单位秒） * @param uri 路径 */public static void setCookie(HttpServletResponse response, String name, String value, String path) { setCookie(response, name, value, path, 60*60*24*365); } /** * 设置 Cookie * @param name 名称 * @param value 值 * @param maxAge 生存时间（单位秒） * @param uri 路径 */public static void setCookie(HttpServletResponse response, String name, String value, int maxAge) { setCookie(response, name, value, "/", maxAge); } /** * 设置 Cookie * @param name 名称 * @param value 值 * @param maxAge 生存时间（单位秒） * @param uri 路径 */public static void setCookie(HttpServletResponse response, String name, String value, String path, int maxAge) { Cookie cookie = new Cookie(name, null); cookie.setPath(path); cookie.setMaxAge(maxAge); try { cookie.setValue(URLEncoder.encode(value, "utf-8")); } catch (UnsupportedEncodingException e) { logger.error("不支持的编码", e); } response.addCookie(cookie); } /** * 获得指定Cookie的值 * @param name 名称 * @return 值 */public static String getCookie(HttpServletRequest request, String name) { return getCookie(request, null, name, false); } /** * 获得指定Cookie的值，并删除。 * @param name 名称 * @return 值 */public static String getCookie(HttpServletRequest request, HttpServletResponse response, String name) { return getCookie(request, response, name, true); } /** * 获得指定Cookie的值 * @param request 请求对象 * @param response 响应对象 * @param name 名字 * @param isRemove 是否移除 * @return 值 */public static String getCookie(HttpServletRequest request, HttpServletResponse response, String name, boolean isRemove) { String value = null; Cookie[] cookies = request.getCookies(); if(cookies == null) { return value; } for (Cookie cookie : cookies) { if (cookie.getName().equals(name)) { try { value = URLDecoder.decode(cookie.getValue(), "utf-8"); } catch (UnsupportedEncodingException e) { logger.error("不支持的编码", e); } if (isRemove) { cookie.setMaxAge(0); response.addCookie(cookie); } } } return value; } } |
SpringContextHolder.java 主要是用来在java代码中获取当前的ApplicationContext，需要在spring配置文件中配置这个bean并且懒加载设置成false；
|
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
|
package com.store.base.secondmodel.base.util; import org.apache.commons.lang3.Validate; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.DisposableBean; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; @Service@Lazy(false) public class SpringContextHolder implements ApplicationContextAware, DisposableBean { private static Logger logger = LoggerFactory.getLogger(SpringContextHolder.class); private static ApplicationContext applicationContext = null; /** * 取得存储在静态变量中的ApplicationContext. */public static ApplicationContext getApplicationContext() { assertContextInjected(); return applicationContext; } /** * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型. */@SuppressWarnings("unchecked") public static <T> T getBean(String name) { assertContextInjected(); return (T) applicationContext.getBean(name); } /** * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型. */public static <T> T getBean(Class<T> requiredType) { assertContextInjected(); return applicationContext.getBean(requiredType); } @Overridepublic void destroy() throws Exception { SpringContextHolder.clearHolder(); } /** * 实现ApplicationContextAware接口, 注入Context到静态变量中. */@Overridepublic void setApplicationContext(ApplicationContext applicationContext) { logger.debug("注入ApplicationContext到SpringContextHolder:{}", applicationContext); SpringContextHolder.applicationContext = applicationContext; if (SpringContextHolder.applicationContext != null) { logger.info("SpringContextHolder中的ApplicationContext被覆盖, 原有ApplicationContext为:" + SpringContextHolder.applicationContext); } } /** * 清除SpringContextHolder中的ApplicationContext为Null. */public static void clearHolder() { if (logger.isDebugEnabled()){ logger.debug("清除SpringContextHolder中的ApplicationContext:" + applicationContext); } applicationContext = null; } /** * 检查ApplicationContext不为空. */private static void assertContextInjected() { Validate.validState(applicationContext != null, "applicaitonContext属性未注入, 请在applicationContext.xml中定义SpringContextHolder."); } } |
StringUtils.java字符串相关的一个工具类
|
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
package com.store.base.secondmodel.base.util; import java.io.UnsupportedEncodingException; import java.util.Locale; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.servlet.http.HttpServletRequest; import org.apache.commons.lang3.StringEscapeUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.web.context.request.RequestContextHolder; import org.springframework.web.context.request.ServletRequestAttributes; import org.springframework.web.servlet.LocaleResolver; import com.store.base.util.Encodes; /** * 字符串帮助类 * @author yiyong_wu * */public class StringUtils extends org.apache.commons.lang3.StringUtils { private static final char SEPARATOR = '_'; private static final String CHARSET_NAME = "UTF-8"; private static final Logger logger = LoggerFactory.getLogger(StringUtils.class); /** * 转换为字节数组 * @param str * @return */public static byte[] getBytes(String str){ if (str != null){ try { return str.getBytes(CHARSET_NAME); } catch (UnsupportedEncodingException e) { logger.error("", e); return new byte[0]; } }else{ return new byte[0]; } } /** * 转换为字节数组 * @param str * @return */public static String toString(byte[] bytes){ try { return new String(bytes, CHARSET_NAME); } catch (UnsupportedEncodingException e) { logger.error("", e); return EMPTY; } } /** * 是否包含字符串 * @param str 验证字符串 * @param strs 字符串组 * @return 包含返回true */public static boolean inString(String str, String... strs){ if (str != null){ for (String s : strs){ if (str.equals(trim(s))){ return true; } } } return false; } /** * 替换掉HTML标签方法 */public static String replaceHtml(String html) { if (isBlank(html)){ return ""; } String regEx = "<.+?>"; Pattern p = Pattern.compile(regEx); Matcher m = p.matcher(html); return m.replaceAll(""); } /** * 替换为手机识别的HTML，去掉样式及属性，保留回车。 * @param html * @return */public static String replaceMobileHtml(String html){ if (html == null){ return ""; } return html.replaceAll("<([a-z]+?)\\s+?.*?>", "<$1>"); } /** * 替换为手机识别的HTML，去掉样式及属性，保留回车。 * @param txt * @return */public static String toHtml(String txt){ if (txt == null){ return ""; } return replace(replace(Encodes.escapeHtml(txt), "\n", "<br/>"), "\t", " "); } /** * 缩略字符串（不区分中英文字符） * @param str 目标字符串 * @param length 截取长度 * @return */public static String abbr(String str, int length) { if (str == null) { return ""; } try { StringBuilder sb = new StringBuilder(); int currentLength = 0; for (char c : replaceHtml(StringEscapeUtils.unescapeHtml4(str)).toCharArray()) { currentLength += String.valueOf(c).getBytes("GBK").length; if (currentLength <= length - 3) { sb.append(c); } else { sb.append("..."); break; } } return sb.toString(); } catch (UnsupportedEncodingException e) { logger.error("", e); } return ""; } /** * 转换为Double类型 */public static Double toDouble(Object val){ if (val == null){ return 0D; } try { return Double.valueOf(trim(val.toString())); } catch (Exception e) { logger.error("", e); return 0D; } } /** * 转换为Float类型 */public static Float toFloat(Object val){ return toDouble(val).floatValue(); } /** * 转换为Long类型 */public static Long toLong(Object val){ return toDouble(val).longValue(); } /** * 转换为Integer类型 */public static Integer toInteger(Object val){ return toLong(val).intValue(); } /** * 获得i18n字符串 */public static String getMessage(String code, Object[] args) { LocaleResolver localLocaleResolver = SpringContextHolder.getBean(LocaleResolver.class); HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest(); Locale localLocale = localLocaleResolver.resolveLocale(request); return SpringContextHolder.getApplicationContext().getMessage(code, args, localLocale); } /** * 获得用户远程地址 */public static String getRemoteAddr(HttpServletRequest request){ String remoteAddr = request.getHeader("X-Real-IP"); if (isNotBlank(remoteAddr)) { remoteAddr = request.getHeader("X-Forwarded-For"); } if (isNotBlank(remoteAddr)) { remoteAddr = request.getHeader("Proxy-Client-IP"); } if (isNotBlank(remoteAddr)) { remoteAddr = request.getHeader("WL-Proxy-Client-IP"); } return remoteAddr != null ? remoteAddr : request.getRemoteAddr(); } /** * 驼峰命名法工具 * @return * toCamelCase("hello_world") == "helloWorld" * toCapitalizeCamelCase("hello_world") == "HelloWorld" * toUnderScoreCase("helloWorld") = "hello_world" */public static String toCamelCase(String s) { String s1 =s; if (s1 == null) { return null; } s1 = s.toLowerCase(); StringBuilder sb = new StringBuilder(s1.length()); boolean upperCase = false; for (int i = 0; i < s1.length(); i++) { char c = s1.charAt(i); if (c == SEPARATOR) { upperCase = true; } else if (upperCase) { sb.append(Character.toUpperCase(c)); upperCase = false; } else { sb.append(c); } } return sb.toString(); } /** * 驼峰命名法工具 * @return * toCamelCase("hello_world") == "helloWorld" * toCapitalizeCamelCase("hello_world") == "HelloWorld" * toUnderScoreCase("helloWorld") = "hello_world" */public static String toCapitalizeCamelCase(String s) { String s1 = s; if (s1 == null) { return null; } s1 = toCamelCase(s1); return s1.substring(0, 1).toUpperCase() + s1.substring(1); } /** * 驼峰命名法工具 * @return * toCamelCase("hello_world") == "helloWorld" * toCapitalizeCamelCase("hello_world") == "HelloWorld" * toUnderScoreCase("helloWorld") = "hello_world" */public static String toUnderScoreCase(String s) { if (s == null) { return null; } StringBuilder sb = new StringBuilder(); boolean upperCase = false; for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); boolean nextUpperCase = true; if (i < (s.length() - 1)) { nextUpperCase = Character.isUpperCase(s.charAt(i + 1)); } if ((i > 0) && Character.isUpperCase(c)) { if (!upperCase || !nextUpperCase) { sb.append(SEPARATOR); } upperCase = true; } else { upperCase = false; } sb.append(Character.toLowerCase(c)); } return sb.toString(); } /** * 转换为JS获取对象值，生成三目运算返回结果 * @param objectString 对象串 * 例如：row.user.id * 返回：!row?'':!row.user?'':!row.user.id?'':row.user.id */public static String jsGetVal(String objectString){ StringBuilder result = new StringBuilder(); StringBuilder val = new StringBuilder(); String[] vals = split(objectString, "."); for (int i=0; i<vals.length; i++){ val.append("." + vals[i]); result.append("!"+(val.substring(1))+"?'':"); } result.append(val.substring(1)); return result.toString(); } } |
有了上面这些基础的东西，只需要在写一个控制层接口，就可以看到每次返回一个page对象，然后里面封装好了查询对象的列表，并且是按分页得出列表。
|
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
|
package com.store.controller; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.RestController; import com.store.base.secondmodel.base.Page; import com.store.base.secondmodel.pratice.model.Product; import com.store.base.secondmodel.pratice.service.ProductService; /** *TODO *2016年10月11日 *yiyong_wu */@RestController@RequestMapping("/product") public class ProductController { @Autowiredprivate ProductService productService; @ResponseBody@RequestMapping(value="/getPageProduct") public Page<Product> getPageProduct(HttpServletRequest request,HttpServletResponse response){ Page<Product> page = productService.findPage(new Page<Product>(request,response), new Product()); return page; } } |
最后在看一下页面怎么使用这个page对象，这样我们就完整地介绍了这个一个分页功能，代码很多，但很完整。
|
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
|
<%@ page contentType="text/html;charset=UTF-8"%> <%@ include file="/WEB-INF/views/include/taglib.jsp"%> <html> <head> <title></title> <meta name="decorator" content="default" /> function page(n, s) { if (n) $("#pageNo").val(n); if (s) $("#pageSize").val(s); $("#searchForm").attr("action", "${ctx}/app/bank/list"); $("#searchForm").submit(); return false; } </script> </head> <body> <form:form id="searchForm" modelAttribute="XXXX" action="${ctx}/XXX" method="post" class="breadcrumb form-search "> <input id="pageNo" name="pageNo" type="hidden" value="${page.pageNo}" /> <input id="pageSize" name="pageSize" type="hidden" value="${page.pageSize}" /> <ul class="ul-form"> <li> <label>是否上架：</label> <form:select id="status" path="status" class="input-medium"> <form:option value="" label=""/> <form:options items="${fns:getDictList('yes_no_app')}" itemLabel="label" itemValue="value" htmlEscape="false"/> </form:select> </li> <li class="btns"><input id="btnSubmit" class="btn btn-primary" type="submit" value="查询"/> <li class="clearfix"></li> </ul> </form:form> <sys:message content="${message}" /> <sys:message content="${message}" /> <table id="contentTable"class="table table-striped table-bordered table-condensed"> <thead> <tr> <th>XXXX</th> <th>XXXX</th> <th>XXXX</th> <th>XXXX</th> <th>XXXX</th> <th>XXXX</th> <th>XXXX</th> <th>XXXX</th> </tr> </thead> <tbody> <c:forEach items="${page.list}" var="XXXX"> <tr> <td>${XXXX.name}</td> <td><a href="${ctx}/app/bank/form?id=${XXXX.id}">${XXXX.}</a></td> <td>${XXXX.}</td> <td>${XXXX.}</td> <td>${XXXX.}</td> <td>${fns:getDictLabel(XXXX.isHot, 'yes_no_app', '无')}</td> <td>${XXXX.}</td> <td><c:if test="${XXXX.status==1 }">上架</c:if> <c:if test="${XXXX.status==2 }">下架</c:if> </td> </tr> </c:forEach> </tbody> </table> <div class="pagination">${page} <li style="padding-top: 6px;padding-left: 12px;float: left;">共${page.count}条</li></div> </body> </html> |
到这里就基本上把整个分页功能描述得比较清楚了，希望可以帮助到你们快速解决分页这个问题，当然要在前端显示分页漂亮的话要针对li做一些css样式啥的，最后祝福你可以快速掌握这个分页功能！
以上所述是小编给大家介绍的Mybatis常用分页插件实现快速分页处理技巧，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持！
原文链接：http://blog.csdn.net/u014001866/article/details/52806930
