释放双眼，带上耳机，听听看~！
在上一节我们已经引入了我们当前工程的所需要的所有的maven依赖，因此本章我们将开始集成swagger2、以及我们抽象实现类的编写,首先大家打开csdn这个工程建好自己相应的包的结构如下所示：
common底下的包主要是用来存放相应的抽象实现类、配置文件、工具类等。
**base:**主要用于存放抽象实现类，后续我们所有的dao、service、controller都将继承我们这里所编写的抽象实现类。
**config:**主要用于存放我们的所有的配置文件的配置类，aop（切面）、init（初始化数据加载）、security（权限控制配置）、swagger（swagger配置类）、webmvc（mvc配置类）。
**util:**主要用于存放我们编写的通用工具，common（全局通用工具类存放位置）、date（时间工具类存放位置）、dict（数据字典工具类存放位置）、json（json工具类存放位置）、node（节点工具类存放位置）、user（用户工具类存放位置）。
sys底下的包主要是用来存放我们实现整个权限架构系统的dao、service、controller、entity的实现类。
1、接着在我们的config的swagger目录底下创建SwaggerConfig.java文件，文件内容如下：
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
2
3import com.google.common.base.Predicate;
4import org.springframework.beans.factory.annotation.Autowired;
5import org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController;
6import org.springframework.context.annotation.Bean;
7import org.springframework.context.annotation.Configuration;
8import org.springframework.core.env.Environment;
9import org.springframework.web.bind.annotation.ResponseBody;
10import org.springframework.web.bind.annotation.RestController;
11import springfox.documentation.RequestHandler;
12import springfox.documentation.builders.ApiInfoBuilder;
13import springfox.documentation.service.ApiInfo;
14import springfox.documentation.spi.DocumentationType;
15import springfox.documentation.spring.web.plugins.Docket;
16import springfox.documentation.swagger2.annotations.EnableSwagger2;
17
18/*
19* 类描述：
20* @auther linzf
21* @create 2018/3/30 0030
22*/
23@Configuration
24@EnableSwagger2
25public class SwaggerConfig {
26
27 @Autowired
28 private Environment env;
29
30
31 @Bean
32 public Docket createRestApi() {
33 Predicate<RequestHandler> predicate = new Predicate<RequestHandler>() {
34 @Override
35 public boolean apply(RequestHandler input) {
36 // 除非是在开发环境中否则不开启swagger2
37 String active = env.getProperty("spring.profiles.active");
38 if(!active.equalsIgnoreCase("dev")){
39 return false;
40 }
41 Class<?> declaringClass = input.declaringClass();
42 if (declaringClass == BasicErrorController.class)// 排除
43 return false;
44 if(declaringClass.isAnnotationPresent(RestController.class)) // 被注解的类
45 return true;
46 if(input.isAnnotatedWith(ResponseBody.class)) // 被注解的方法
47 return true;
48 return false;
49 }
50 };
51 return new Docket(DocumentationType.SWAGGER_2)
52 .apiInfo(apiInfo())
53 .useDefaultResponseMessages(false)
54 .select()
55 .apis(predicate)
56 .build();
57 }
58
59 private ApiInfo apiInfo() {
60 return new ApiInfoBuilder()
61 .title("mongodb 接口测试专用页面！")//大标题
62 .version("1.0")//版本
63 .build();
64 }
65
66}
67
68
2、接着我们在我们的common的base目录底下创建我们的抽象实现类
**
在我们实现以下的抽象实现类的时候，我们首先要先实现以下的两个工具类，分别是util的common目录的CommonUtil.java和util的json目录的JsonHelper.java文件，二者的文件内容如下：
**
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
2
3/*
4* 类描述：
5* @auther linzf
6* @create 2018/4/11 0011
7*/
8public class CommonUtil {
9
10 /**
11 * 将首字母变小写
12 * @param str
13 * @return
14 */
15 public static String toFirstCharLowerCase(String str){
16 char[] columnCharArr = str.toCharArray();
17 StringBuffer sb = new StringBuffer();
18 for (int i = 0; i < columnCharArr.length; i++) {
19 char cur = columnCharArr[i];
20 if(i==0){
21 sb.append(Character.toLowerCase(cur));
22 }else{
23 sb.append(cur);
24 }
25 }
26 return sb.toString();
27 }
28}
29
30
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
2
3
4
5import net.sf.json.JSONArray;
6import net.sf.json.JSONObject;
7
8import java.beans.IntrospectionException;
9import java.beans.Introspector;
10import java.beans.PropertyDescriptor;
11import java.math.BigDecimal;
12import java.math.BigInteger;
13import java.text.SimpleDateFormat;
14import java.util.*;
15
16/*
17* 类描述：json工具类
18* @auther linzf
19* @create 2017/8/23 0023
20*/
21public class JsonHelper {
22
23 private static SimpleDateFormat sdf = new SimpleDateFormat(
24 "yyyy-MM-dd HH:mm:ss");
25
26 // 将JSON转换成Map,其中valueClz为Map中value的Class,keyArray为Map的key
27 public static Map json2Map(Object[] keyArray, String json, Class valueClz) {
28 JSONObject jsonObject = JSONObject.fromObject(json);
29 Map classMap = new HashMap();
30 for (int i = 0; i < keyArray.length; i++) {
31 classMap.put(keyArray[i], valueClz);
32 }
33 return (Map) JSONObject.toBean(jsonObject, Map.class, classMap);
34 }
35
36 /***
37 * 将对象转换为传入类型的List
38 *
39 * @param object
40 * @param objectClass
41 * @return
42 */
43 public static <T> Collection<T> toList(Object object, Class<T> objectClass) {
44 JSONArray jsonArray = JSONArray.fromObject(object);
45 return JSONArray.toCollection(jsonArray, objectClass);
46 }
47
48 /**
49 * 功能描述：实现将一个object对象转换为json的string字符串
50 * @param obj
51 * @return
52 */
53 public static String object2json(Object obj) {
54 StringBuilder json = new StringBuilder();
55 if (obj == null) {
56 json.append("\"\"");
57 } else if (obj instanceof String || obj instanceof BigDecimal
58 || obj instanceof BigInteger) {
59 json.append("\"").append(string2json(obj.toString())).append("\"");
60 } else if (obj instanceof Boolean) {
61 json.append(Boolean.valueOf(obj.toString()));
62 } else if (obj instanceof Integer || obj instanceof Float
63 || obj instanceof Short || obj instanceof Double
64 || obj instanceof Long || obj instanceof Byte) {
65 json.append(obj.toString());
66 } else if (obj instanceof Date || obj instanceof java.sql.Date) {
67 json.append("\"").append(sdf.format(obj)).append("\"");
68 } else if (obj instanceof Object[]) {
69 json.append(array2json((Object[]) obj));
70 } else if (obj instanceof List) {
71 json.append(list2json((List<?>) obj));
72 } else if (obj instanceof Map) {
73 json.append(map2json((Map<?, ?>) obj));
74 } else if (obj instanceof Set) {
75 json.append(set2json((Set<?>) obj));
76 } else {
77 json.append(bean2json(obj));
78 }
79 return json.toString();
80 }
81
82 public static String list2json(List<?> list) {
83 StringBuilder json = new StringBuilder();
84 json.append("[");
85 if (list != null && list.size() > 0) {
86 for (Object obj : list) {
87 json.append(object2json(obj));
88 json.append(",");
89 }
90 json.setCharAt(json.length() - 1, ']');
91 } else {
92 json.append("]");
93 }
94 return json.toString();
95 }
96
97 public static String array2json(Object[] array) {
98 StringBuilder json = new StringBuilder();
99 json.append("[");
100 if (array != null && array.length > 0) {
101 for (Object obj : array) {
102 json.append(object2json(obj));
103 json.append(",");
104 }
105 json.setCharAt(json.length() - 1, ']');
106 } else {
107 json.append("]");
108 }
109 return json.toString();
110 }
111
112 public static String map2json(Map<?, ?> map) {
113 StringBuilder json = new StringBuilder();
114 json.append("{");
115 if (map != null && map.size() > 0) {
116 for (Object key : map.keySet()) {
117 json.append(object2json(key));
118 json.append(":");
119 json.append(object2json(map.get(key)));
120 json.append(",");
121 }
122 json.setCharAt(json.length() - 1, '}');
123 } else {
124 json.append("}");
125 }
126 return json.toString();
127 }
128
129 public static String set2json(Set<?> set) {
130 StringBuilder json = new StringBuilder();
131 json.append("[");
132 if (set != null && set.size() > 0) {
133 for (Object obj : set) {
134 json.append(object2json(obj));
135 json.append(",");
136 }
137 json.setCharAt(json.length() - 1, ']');
138 } else {
139 json.append("]");
140 }
141 return json.toString();
142 }
143
144 public static String string2json(String s) {
145 if (s == null)
146 return "";
147 StringBuilder sb = new StringBuilder();
148 for (int i = 0; i < s.length(); i++) {
149 char ch = s.charAt(i);
150 switch (ch) {
151 case '"':
152 sb.append("\\\"");
153 break;
154 case '\\':
155 sb.append("\\\\");
156 break;
157 case '\b':
158 sb.append("\\b");
159 break;
160 case '\f':
161 sb.append("\\f");
162 break;
163 case '\n':
164 sb.append("\\n");
165 break;
166 case '\r':
167 sb.append("\\r");
168 break;
169 case '\t':
170 sb.append("\\t");
171 break;
172 case '/':
173 sb.append("\\/");
174 break;
175 default:
176 if (ch >= '\u0000' && ch <= '\u001F') {
177 String ss = Integer.toHexString(ch);
178 sb.append("\\u");
179 for (int k = 0; k < 4 - ss.length(); k++) {
180 sb.append('0');
181 }
182 sb.append(ss.toUpperCase());
183 } else {
184 sb.append(ch);
185 }
186 }
187 }
188 return sb.toString();
189 }
190
191 public static String bean2json(Object bean) {
192 StringBuilder json = new StringBuilder();
193 json.append("{");
194 PropertyDescriptor[] props = null;
195 try {
196 props = Introspector.getBeanInfo(bean.getClass(), Object.class)
197 .getPropertyDescriptors();
198 } catch (IntrospectionException e) {
199 }
200 if (props != null) {
201 for (int i = 0; i < props.length; i++) {
202 try {
203 String name = object2json(props[i].getName());
204 String value = object2json(props[i].getReadMethod().invoke(
205 bean));
206 json.append(name);
207 json.append(":");
208 json.append(value);
209 json.append(",");
210 } catch (Throwable e) {
211 }
212 }
213 json.setCharAt(json.length() - 1, '}');
214 } else {
215 json.append("}");
216 }
217 return json.toString();
218 }
219
220
221}
222
223
2.1、首先在我们的constant目录底下新建一个SystemStaticConst.java通用常量类，主要用于存放常用静态常量。
2
3
4
5
6
7
8
9
10
11
12
13
2/**
3 * Created by Administrator on 2017/8/7 0007.
4 */
5public class SystemStaticConst {
6
7 public final static String RESULT = "success";
8 public final static boolean SUCCESS = true;
9 public final static boolean FAIL = false;
10 public final static String MSG = "msg";
11
12}
13
** 2.2、接着编写我们的通用实体类、通用实体类主要包含Pagination（分页实体类）、QueryBase（查询实体类）、QueryField（实体Bean上注解查询的类）、QueryType（实体上查询的枚举类型）。**
2.2.1、
Pagination：主要是对页面的分页进行封装，代码如下：
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
2
3import java.util.List;
4
5public class Pagination<T> {
6
7 public Pagination(){
8 super();
9 }
10
11 public Pagination(Integer currentPage,Integer totalPage,Integer totalNumber){
12 this.currentPage = currentPage;
13 this.totalPage = totalPage;
14 this.totalNumber = totalNumber;
15 }
16
17 /**
18 * 每页显示条数
19 */
20 private Integer pageSize = 8;
21
22 /**
23 * 当前页
24 */
25 private Integer currentPage = 1;
26
27 /**
28 * 总页数
29 */
30 private Integer totalPage = 1;
31
32 /**
33 * 查询到的总数据量
34 */
35 private Integer totalNumber = 0;
36
37 /**
38 * 数据集
39 */
40 private List items;
41
42 public Integer getPageSize() {
43 return pageSize;
44 }
45
46 public void setPageSize(Integer pageSize) {
47 this.pageSize = pageSize;
48 }
49
50 public Integer getCurrentPage() {
51 return currentPage;
52 }
53
54 public void setCurrentPage(Integer currentPage) {
55 this.currentPage = currentPage;
56 }
57
58 public Integer getTotalPage() {
59 return totalPage;
60 }
61
62 public void setTotalPage(Integer totalPage) {
63 this.totalPage = totalPage;
64 }
65
66 public Integer getTotalNumber() {
67 return totalNumber;
68 }
69
70 public void setTotalNumber(Integer totalNumber) {
71 this.totalNumber = totalNumber;
72 }
73
74 public List getItems() {
75 return items;
76 }
77
78 public void setItems(List items) {
79 this.items = items;
80 }
81
82 /**
83 * 处理查询后的结果数据
84 *
85 * @param items 查询结果集
86 */
87 public void build(List items) {
88 this.setItems(items);
89 int count = this.getTotalNumber();
90 int divisor = count / this.getPageSize();
91 int remainder = count % this.getPageSize();
92 this.setTotalPage(remainder == 0 ? divisor == 0 ? 1 : divisor : divisor + 1);
93 }
94}
95
96
2.2.2、QueryBase：实现对查询实体的封装，代码如下：
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
2
3public class QueryBase {
4
5 /**
6 * 页数
7 */
8 protected int page;
9
10 /**
11 * 获取一页行数
12 * */
13 protected int limit;
14
15
16 public int getPage() {
17 return page;
18 }
19
20 public void setPage(int page) {
21 this.page = page;
22 }
23
24 public int getLimit() {
25 return limit;
26 }
27
28 public void setLimit(int limit) {
29 this.limit = limit;
30 }
31}
32
33
2.2.3、QueryType：查询类型的媒介类，主要用于确定那些字段需要在查询的时候使用到，也许在这里大家可能还不是很明白，等到下一章我们开始编写具体的业务实现的时候，大家就会明白该枚举的作用。
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
2
3/**
4 * Created by Administrator on 2018/3/30 0030.
5 */
6
7import org.springframework.data.mongodb.core.query.Criteria;
8import org.springframework.util.StringUtils;
9
10import java.lang.reflect.Field;
11import java.util.List;
12
13/**
14 * <p>
15 * 查询类型的媒介类<br/>
16 * 目前有支持三种类型：<br/>
17 * 1. equals：相等
18 * 2. like:mongodb的like查询
19 * 3. in:用于列表的in类型查询
20 * </p>
21 *
22 */
23public enum QueryType {
24 EQUALS {
25 @Override
26 public Criteria buildCriteria(QueryField queryFieldAnnotation, Field field, Object value) {
27 if (check(queryFieldAnnotation, field, value)) {
28 String queryField = getQueryFieldName(queryFieldAnnotation, field);
29 return Criteria.where(queryField).is(value.toString());
30 }
31 return new Criteria();
32 }
33 },
34 LIKE {
35 @Override
36 public Criteria buildCriteria(QueryField queryFieldAnnotation, Field field, Object value) {
37 if (check(queryFieldAnnotation, field, value)) {
38 String queryField = getQueryFieldName(queryFieldAnnotation, field);
39 return Criteria.where(queryField).regex(value.toString());
40 }
41 return new Criteria();
42 }
43 },
44 IN {
45 @Override
46 public Criteria buildCriteria(QueryField queryFieldAnnotation, Field field, Object value) {
47 if (check(queryFieldAnnotation, field, value)) {
48 if (value instanceof List) {
49 String queryField = getQueryFieldName(queryFieldAnnotation, field);
50 // 此处必须转型为List，否则会在in外面多一层[]
51 return Criteria.where(queryField).in((List<?>)value);
52 }
53 }
54 return new Criteria();
55 }
56 };
57
58 private static boolean check(QueryField queryField, Field field, Object value) {
59 return !(queryField == null || field == null || value == null);
60 }
61
62 public abstract Criteria buildCriteria(QueryField queryFieldAnnotation, Field field, Object value);
63
64 /**
65 * 如果实体bean的字段上QueryField注解没有设置attribute属性时，默认为该字段的名称
66 *
67 * @param queryField
68 * @param field
69 * @return
70 */
71 private static String getQueryFieldName(QueryField queryField, Field field) {
72 String queryFieldValue = queryField.attribute();
73 if (!StringUtils.hasText(queryFieldValue)) {
74 queryFieldValue = field.getName();
75 }
76 return queryFieldValue;
77 }
78}
79
2.2.4、QueryField：用于实体Bean的属性上的注解，注解有两个属性可以设置，type表示查询类似，默认为equals，此块也是等到下一章具体使用的时候再和大家详细介绍，代码如下所示：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3import java.lang.annotation.ElementType;
4import java.lang.annotation.Retention;
5import java.lang.annotation.RetentionPolicy;
6import java.lang.annotation.Target;
7
8/**
9 * <p>
10 * 用于实体Bean的属性上的注解，注解有两个属性可以设置，type表示查询类似，默认为equals<br/>
11 * attribute表示要查询的属性，默认为空串，在使用时如果为空串，则默认为实体Bean字段的名称
12 * </p>
13 *
14 */
15@Target(ElementType.FIELD)
16@Retention(RetentionPolicy.RUNTIME)
17public @interface QueryField {
18 QueryType type() default QueryType.EQUALS;
19 String attribute() default "";
20}
21
22
2.3、接着再我们的base的dao目录底下编写我们的dao层的数据库抽象实现类（MongodbBaseService），代码如下所示：
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
2
3
4import com.mongo.common.base.entity.Pagination;
5import com.mongo.common.base.entity.QueryBase;
6import com.mongo.common.base.entity.QueryField;
7import com.mongo.common.util.common.CommonUtil;
8import org.springframework.beans.factory.annotation.Autowired;
9import org.springframework.beans.factory.annotation.Qualifier;
10import org.springframework.data.mongodb.core.MongoTemplate;
11import org.springframework.data.mongodb.core.query.Criteria;
12import org.springframework.data.mongodb.core.query.Query;
13import org.springframework.data.mongodb.core.query.Update;
14
15import java.lang.reflect.Field;
16import java.lang.reflect.ParameterizedType;
17import java.util.List;
18
19/*
20* 类描述：
21* @auther linzf
22* @create 2018/3/30 0030
23*/
24public abstract class MongodbBaseDao<T,Q extends QueryBase>{
25
26 @Autowired
27 @Qualifier("mongoTemplate")
28 protected MongoTemplate mongoTemplate;
29
30 //保存一个对象到mongodb
31 public T save(T bean) {
32 mongoTemplate.save(bean);
33 return bean;
34 }
35
36 // 根据id删除对象
37 public void deleteById(T t) {
38 mongoTemplate.remove(t);
39 }
40
41 // 根据对象的属性删除
42 public void deleteByCondition(T t) {
43 Query query = buildBaseQuery(t);
44 mongoTemplate.remove(query, getEntityClass());
45 }
46
47 // 通过条件查询更新数据
48 public void update(Query query, Update update) {
49 mongoTemplate.updateMulti(query, update, this.getEntityClass());
50 }
51
52 // 根据id进行更新
53 public void updateById(String id, T t) {
54 Query query = new Query();
55 query.addCriteria(Criteria.where("id").is(id));
56 Update update = buildBaseUpdate(t);
57 update(query, update);
58 }
59
60 // 通过条件查询实体(集合)
61 public List<T> find(Query query) {
62 return mongoTemplate.find(query, this.getEntityClass());
63 }
64
65 public List<T> findByCondition(T t) {
66 Query query = buildBaseQuery(t);
67 return mongoTemplate.find(query, getEntityClass());
68 }
69
70 // 通过一定的条件查询一个实体
71 public T findOne(Query query) {
72 return mongoTemplate.findOne(query, this.getEntityClass());
73 }
74
75
76 // 通过ID获取记录
77 public T get(String id) {
78 return mongoTemplate.findById(id, this.getEntityClass());
79 }
80
81 // 通过ID获取记录,并且指定了集合名(表的意思)
82 public T get(String id, String collectionName) {
83 return mongoTemplate.findById(id, this.getEntityClass(), collectionName);
84 }
85
86 /**
87 * 通过条件查询,查询分页结果
88 */
89 public Pagination<T> findByPage(Q q) {
90 Query query = buildBaseQuery(q);
91 //获取总条数
92 long totalCount = this.mongoTemplate.count(query, this.getEntityClass());
93 //总页数
94 int totalPage = (int) (totalCount/q.getLimit());
95 int skip = (q.getPage()-1)*q.getLimit();
96 Pagination<T> page = new Pagination(q.getPage(), totalPage, (int)totalCount);
97 query.skip(skip);// skip相当于从那条记录开始
98 query.limit(q.getLimit());// 从skip开始,取多少条记录
99 List<T> data = this.find(query);
100 page.build(data);//获取数据
101 return page;
102 }
103
104 /**
105 * 根据注解构建Query查询条件
106 * @param q
107 * @return
108 */
109 public Query buildBaseQuery(Q q){
110 Query query = new Query();
111
112 Field[] fields = q.getClass().getDeclaredFields();
113 for (Field field : fields) {
114 field.setAccessible(true);
115 try {
116 Object value = field.get(q);
117 if (value != null&&!value.equals("")) {
118 QueryField queryField = field.getAnnotation(QueryField.class);
119 if (queryField != null) {
120 if(value instanceof String){
121 query.addCriteria(queryField.type().buildCriteria(queryField, field, value));
122 }else{
123 query.addCriteria(queryField.type().buildCriteria(queryField, field, value));
124 }
125 }
126 }
127 } catch (IllegalArgumentException e) {
128 e.printStackTrace();
129 } catch (IllegalAccessException e) {
130 e.printStackTrace();
131 }
132 }
133 return query;
134 }
135
136 // 根据vo构建查询条件Query
137 private Query buildBaseQuery(T t) {
138 Query query = new Query();
139
140 Field[] fields = t.getClass().getDeclaredFields();
141 for (Field field : fields) {
142 field.setAccessible(true);
143 try {
144 Object value = field.get(t);
145 if (value != null) {
146 QueryField queryField = field.getAnnotation(QueryField.class);
147 if (queryField != null) {
148 query.addCriteria(queryField.type().buildCriteria(queryField, field, value));
149 }
150 }
151 } catch (IllegalArgumentException e) {
152 e.printStackTrace();
153 } catch (IllegalAccessException e) {
154 e.printStackTrace();
155 }
156 }
157 return query;
158 }
159
160 private Update buildBaseUpdate(T t) {
161 Update update = new Update();
162
163 Field[] fields = t.getClass().getDeclaredFields();
164 for (Field field : fields) {
165 field.setAccessible(true);
166 try {
167 Object value = field.get(t);
168 if (value != null) {
169 update.set(field.getName(), value);
170 }
171 } catch (Exception e) {
172 e.printStackTrace();
173 }
174 }
175 return update;
176 }
177
178 // 获取需要操作的实体类class
179 @SuppressWarnings("unchecked")
180 protected Class<T> getEntityClass() {
181 return ((Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
182 }
183
184 protected String getCollection(){
185 String [] collections = getEntityClass().toString().split("\\.");
186 return CommonUtil.toFirstCharLowerCase(collections[collections.length-1]);
187 }
188
189 public MongoTemplate getMongoTemplate() {
190 return mongoTemplate;
191 }
192}
193
**2.4、接着再我们的base的service目录底下编写我们的service层的业务抽象实现类（**MongodbBaseDao
），代码如下所示：
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
2
3
4import com.mongo.common.base.dao.MongodbBaseDao;
5import com.mongo.common.base.entity.Pagination;
6import com.mongo.common.base.entity.QueryBase;
7import org.springframework.data.mongodb.core.query.Query;
8import org.springframework.data.mongodb.core.query.Update;
9
10import java.util.List;
11
12public abstract class MongodbBaseService<T,Q extends QueryBase> {
13
14 protected abstract MongodbBaseDao<T,Q> getDao();
15
16 //保存一个对象到mongodb
17 public T save(T bean) {
18 getDao().save(bean);
19 return bean;
20 }
21
22 // 根据id删除对象
23 public void deleteById(T t) {
24 getDao().deleteById(t);
25 }
26
27 /**
28 * 功能描述：批量删除数据
29 * @param entityList
30 * @return
31 */
32 public boolean removeBath(List<T> entityList) throws Exception{
33 for(T t:entityList){
34 deleteById(t);
35 }
36 return true;
37 }
38
39 // 根据对象的属性删除
40 public void deleteByCondition(T t) {
41 getDao().deleteByCondition(t);
42 }
43
44 // 通过条件查询更新数据
45 public void update(Query query, Update update){
46 getDao().update(query,update);
47 }
48
49 // 根据id进行更新
50 public void updateById(String id, T t){
51 getDao().updateById(id,t);
52 }
53
54 // 通过条件查询实体(集合)
55 public List<T> find(Query query) {
56 return getDao().find(query);
57 }
58
59 public List<T> findByCondition(T t){
60 return getDao().findByCondition(t);
61 }
62
63 public T findOne(Query query){
64 return getDao().findOne(query);
65 }
66
67 // 通过ID获取记录
68 public T get(String id){
69 return getDao().get(id);
70 }
71
72 // 通过ID获取记录,并且指定了集合名(表的意思)
73 public T get(String id, String collectionName){
74 return getDao().get(id,collectionName);
75 }
76
77
78 /**
79 * 通过条件查询,查询分页结果
80 */
81 public Pagination<T> findByPage(Q q){
82 return getDao().findByPage(q);
83 }
84
85}
86
87
** 2.5、接着再我们的base的controller目录底下编写我们的controller层的抽象实现类（**MongodbBaseController
），代码如下所示：
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
2
3
4import com.mongo.common.base.constant.SystemStaticConst;
5import com.mongo.common.base.entity.QueryBase;
6import com.mongo.common.base.service.MongodbBaseService;
7import com.mongo.common.util.common.CommonUtil;
8import com.mongo.common.util.json.JsonHelper;
9import org.springframework.http.MediaType;
10import org.springframework.ui.Model;
11import org.springframework.web.bind.annotation.RequestMapping;
12import org.springframework.web.bind.annotation.RequestMethod;
13import org.springframework.web.bind.annotation.ResponseBody;
14
15import java.lang.reflect.ParameterizedType;
16import java.util.HashMap;
17import java.util.List;
18import java.util.Map;
19import java.util.regex.Matcher;
20import java.util.regex.Pattern;
21
22public abstract class MongodbBaseController<T,Q extends QueryBase> {
23
24 protected abstract MongodbBaseService<T,Q> getService();
25
26 /**添加页面路径*/
27 public final static String ADDPAGE = "/add";
28 /**修改页面路径*/
29 public final static String UPDATEPAGE = "/update";
30
31 /**
32 * Controller基路径
33 * */
34 protected String basePath;
35
36 /**抽象方法，获取页面基路径
37 * @throws Exception */
38 protected String getPageBaseRoot() throws Exception{
39 if(basePath==null){
40 basePath = this.getClass().getName();
41 Pattern p=Pattern.compile(".[a-z|A-z]+.controller.[a-z|A-z]+Controller");
42 Matcher m=p.matcher(basePath);
43 if(m.find()){
44 basePath = m.group();
45 basePath = basePath.substring(1, basePath.length()-10);
46 basePath = basePath.replace(".", "/");
47 basePath = basePath.replace("/controller/", "/");
48 basePath = CommonUtil.toFirstCharLowerCase(basePath);
49 basePath = basePath.substring(0,basePath.lastIndexOf("/")+1)+CommonUtil.toFirstCharLowerCase(basePath.substring(basePath.lastIndexOf("/")+1));
50 }
51 else{
52 throw new Exception("获取页面基路径失败");
53 }
54 }
55 return basePath;
56 }
57
58 /**
59 * 功能描述：直接跳转到更新数据的页面
60 * @param id
61 * @return
62 */
63 @RequestMapping(value = "/updatePage",method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
64 public String updatePage(String id,Model model) throws Exception{
65 T entity = getService().get(id);
66 model.addAttribute("entity",entity);
67 return getPageBaseRoot()+UPDATEPAGE;
68 }
69
70 /** 跳转到添加对象页面
71 * @throws Exception */
72 @RequestMapping(value="/addPage")
73 public String addPage() throws Exception{
74 return getPageBaseRoot()+ADDPAGE;
75 }
76
77 /**
78 * 功能描述：保存数据字典数据
79 * @param entity
80 * @return
81 */
82 @RequestMapping(value = "/save",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
83 @ResponseBody
84 public Map<String,Object> save(T entity) throws Exception{
85 entity = getService().save(entity);
86 Map<String,Object> result = new HashMap<String, Object>();
87 if(entity!=null){
88 result.put(SystemStaticConst.RESULT,SystemStaticConst.SUCCESS);
89 result.put(SystemStaticConst.MSG,"增加数据成功！");
90 result.put("entity",entity);
91 }else{
92 result.put(SystemStaticConst.RESULT,SystemStaticConst.FAIL);
93 result.put(SystemStaticConst.MSG,"增加数据失败！");
94 }
95 return result;
96 }
97
98
99 /**
100 * 功能描述：更新数据字典数据
101 * @param entity
102 * @return
103 */
104 @RequestMapping(value = "/update",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
105 @ResponseBody
106 public Map<String,Object> update(String id,T entity) throws Exception{
107 Map<String,Object> result = new HashMap<String, Object>();
108 try{
109 getService().updateById(id,entity);
110 result.put(SystemStaticConst.RESULT,SystemStaticConst.SUCCESS);
111 result.put(SystemStaticConst.MSG,"更新数据成功！");
112 result.put("entity",entity);
113 }catch(Exception e){
114 result.put(SystemStaticConst.RESULT,SystemStaticConst.FAIL);
115 result.put(SystemStaticConst.MSG,"更新数据失败！");
116 }
117 return result;
118 }
119
120 /**
121 * 功能描述：实现根据ID来删除数据
122 * @param entity
123 * @return
124 */
125 @RequestMapping(value = "/remove",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
126 @ResponseBody
127 public Map<String,Object> remove(T entity) throws Exception{
128 Map<String,Object> result = new HashMap<String, Object>();
129 getService().deleteById(entity);
130 result.put(SystemStaticConst.RESULT,SystemStaticConst.SUCCESS);
131 result.put(SystemStaticConst.MSG,"删除数据成功！");
132 return result;
133 }
134
135 /**
136 * 功能描述：实现批量删除数据字典的记录
137 * @param json
138 * @return
139 */
140 @RequestMapping(value = "/removeBath",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
141 @ResponseBody
142 public Map<String,Object> removeBath(String json) throws Exception{
143 Map<String,Object> result = new HashMap<String, Object>();
144 getService().removeBath((List<T>) JsonHelper.toList(json,(Class <T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]));
145 result.put(SystemStaticConst.RESULT,SystemStaticConst.SUCCESS);
146 result.put(SystemStaticConst.MSG,"删除数据成功！");
147 return result;
148 }
149
150 /**
151 * 功能描述：判断当前的字典元素是否已经存在
152 * @param entity
153 * @return
154 */
155 @RequestMapping(value = "/isExist",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
156 @ResponseBody
157 public Map<String,Object> isExist(T entity){
158 Map<String,Object> result = new HashMap<String, Object>();
159 if(getService().findByCondition(entity).size()>0){
160 result.put("valid",false);
161 }else{
162 result.put("valid",true);
163 }
164 return result;
165 }
166
167
168
169}
170
171
到此我们完成了我们的swagger和抽象实现类的实现，到本章为止大家虽然可以运行起来项目，可是是看不到实际的效果的，在下一章我们将集成我们的security实现用户的登陆功能。
到此为止的GitHub项目地址：https://github.com/185594-5-27/csdn/tree/master-base-3
上一篇文章地址：基于spring boot和mongodb打造一套完整的权限架构（二）【MAVEN依赖以及相应配置】
下一篇文章地址：基于spring boot和mongodb打造一套完整的权限架构（四）【完全集成security】
QQ交流群：578746866
