基于spring boot和mongodb打造一套完整的权限架构（三）【抽象实现类和swagger的实现】

ゝ一纸荒年。 2022-05-27 09:14 135阅读 0赞

在上一节我们已经引入了我们当前工程的所需要的所有的maven依赖，因此本章我们将开始集成swagger2、以及我们抽象实现类的编写,首先大家打开csdn这个工程建好自己相应的包的结构如下所示：

![20180416094839596][]

**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文件，文件内容如下：**

package com.mongo.common.config.swagger;
 
 import com.google.common.base.Predicate;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.env.Environment;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController;
 import springfox.documentation.RequestHandler;
 import springfox.documentation.builders.ApiInfoBuilder;
 import springfox.documentation.service.ApiInfo;
 import springfox.documentation.spi.DocumentationType;
 import springfox.documentation.spring.web.plugins.Docket;
 import springfox.documentation.swagger2.annotations.EnableSwagger2;
 
 /*
 * 类描述：
 * @auther linzf
 * @create 2018/3/30 0030 
 */
 @Configuration
 @EnableSwagger2
 public class SwaggerConfig {
 
 @Autowired
 private Environment env;
 
 
 @Bean
 public Docket createRestApi() {
 Predicate<RequestHandler> predicate = new Predicate<RequestHandler>() {
 @Override
 public boolean apply(RequestHandler input) {
 // 除非是在开发环境中否则不开启swagger2
 String active = env.getProperty("spring.profiles.active");
 if(!active.equalsIgnoreCase("dev")){
 return false;
 }
 Class<?> declaringClass = input.declaringClass();
 if (declaringClass == BasicErrorController.class)// 排除
 return false;
 if(declaringClass.isAnnotationPresent(RestController.class)) // 被注解的类
 return true;
 if(input.isAnnotatedWith(ResponseBody.class)) // 被注解的方法
 return true;
 return false;
 }
 };
 return new Docket(DocumentationType.SWAGGER_2)
 .apiInfo(apiInfo())
 .useDefaultResponseMessages(false)
 .select()
 .apis(predicate)
 .build();
 }
 
 private ApiInfo apiInfo() {
 return new ApiInfoBuilder()
 .title("mongodb 接口测试专用页面！")//大标题
 .version("1.0")//版本
 .build();
 }
 
 }

**2、接着我们在我们的common的base目录底下创建我们的抽象实现类**

**        在我们实现以下的抽象实现类的时候，我们首先要先实现以下的两个工具类，分别是util的common目录的CommonUtil.java和util的json目录的JsonHelper.java文件，二者的文件内容如下：**

package com.mongo.common.util.common;
 
 /*
 * 类描述：
 * @auther linzf
 * @create 2018/4/11 0011 
 */
 public class CommonUtil {
 
 /**
 * 将首字母变小写
 * @param str
 * @return
 */
 public static String toFirstCharLowerCase(String str){
 char[] columnCharArr = str.toCharArray();
 StringBuffer sb = new StringBuffer();
 for (int i = 0; i < columnCharArr.length; i++) {
 char cur = columnCharArr[i];
 if(i==0){
 sb.append(Character.toLowerCase(cur));
 }else{
 sb.append(cur);
 }
 }
 return sb.toString();
 }
 }

package com.mongo.common.util.json;
 
 
 
 import net.sf.json.JSONArray;
 import net.sf.json.JSONObject;
 
 import java.beans.IntrospectionException;
 import java.beans.Introspector;
 import java.beans.PropertyDescriptor;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.text.SimpleDateFormat;
 import java.util.*;
 
 /*
 * 类描述：json工具类
 * @auther linzf
 * @create 2017/8/23 0023 
 */
 public class JsonHelper {
 
 private static SimpleDateFormat sdf = new SimpleDateFormat(
 "yyyy-MM-dd HH:mm:ss");
 
 // 将JSON转换成Map,其中valueClz为Map中value的Class,keyArray为Map的key
 public static Map json2Map(Object[] keyArray, String json, Class valueClz) {
 JSONObject jsonObject = JSONObject.fromObject(json);
 Map classMap = new HashMap();
 for (int i = 0; i < keyArray.length; i++) {
 classMap.put(keyArray[i], valueClz);
 }
 return (Map) JSONObject.toBean(jsonObject, Map.class, classMap);
 }
 
 /***
 * 将对象转换为传入类型的List
 *
 * @param object
 * @param objectClass
 * @return
 */
 public static <T> Collection<T> toList(Object object, Class<T> objectClass) {
 JSONArray jsonArray = JSONArray.fromObject(object);
 return JSONArray.toCollection(jsonArray, objectClass);
 }
 
 /**
 * 功能描述：实现将一个object对象转换为json的string字符串
 * @param obj
 * @return
 */
 public static String object2json(Object obj) {
 StringBuilder json = new StringBuilder();
 if (obj == null) {
 json.append("\"\"");
 } else if (obj instanceof String || obj instanceof BigDecimal
 || obj instanceof BigInteger) {
 json.append("\"").append(string2json(obj.toString())).append("\"");
 } else if (obj instanceof Boolean) {
 json.append(Boolean.valueOf(obj.toString()));
 } else if (obj instanceof Integer || obj instanceof Float
 || obj instanceof Short || obj instanceof Double
 || obj instanceof Long || obj instanceof Byte) {
 json.append(obj.toString());
 } else if (obj instanceof Date || obj instanceof java.sql.Date) {
 json.append("\"").append(sdf.format(obj)).append("\"");
 } else if (obj instanceof Object[]) {
 json.append(array2json((Object[]) obj));
 } else if (obj instanceof List) {
 json.append(list2json((List<?>) obj));
 } else if (obj instanceof Map) {
 json.append(map2json((Map<?, ?>) obj));
 } else if (obj instanceof Set) {
 json.append(set2json((Set<?>) obj));
 } else {
 json.append(bean2json(obj));
 }
 return json.toString();
 }
 
 public static String list2json(List<?> list) {
 StringBuilder json = new StringBuilder();
 json.append("[");
 if (list != null && list.size() > 0) {
 for (Object obj : list) {
 json.append(object2json(obj));
 json.append(",");
 }
 json.setCharAt(json.length() - 1, ']');
 } else {
 json.append("]");
 }
 return json.toString();
 }
 
 public static String array2json(Object[] array) {
 StringBuilder json = new StringBuilder();
 json.append("[");
 if (array != null && array.length > 0) {
 for (Object obj : array) {
 json.append(object2json(obj));
 json.append(",");
 }
 json.setCharAt(json.length() - 1, ']');
 } else {
 json.append("]");
 }
 return json.toString();
 }
 
 public static String map2json(Map<?, ?> map) {
 StringBuilder json = new StringBuilder();
 json.append("{");
 if (map != null && map.size() > 0) {
 for (Object key : map.keySet()) {
 json.append(object2json(key));
 json.append(":");
 json.append(object2json(map.get(key)));
 json.append(",");
 }
 json.setCharAt(json.length() - 1, '}');
 } else {
 json.append("}");
 }
 return json.toString();
 }
 
 public static String set2json(Set<?> set) {
 StringBuilder json = new StringBuilder();
 json.append("[");
 if (set != null && set.size() > 0) {
 for (Object obj : set) {
 json.append(object2json(obj));
 json.append(",");
 }
 json.setCharAt(json.length() - 1, ']');
 } else {
 json.append("]");
 }
 return json.toString();
 }
 
 public static String string2json(String s) {
 if (s == null)
 return "";
 StringBuilder sb = new StringBuilder();
 for (int i = 0; i < s.length(); i++) {
 char ch = s.charAt(i);
 switch (ch) {
 case '"':
 sb.append("\\\"");
 break;
 case '\\':
 sb.append("\\\\");
 break;
 case '\b':
 sb.append("\\b");
 break;
 case '\f':
 sb.append("\\f");
 break;
 case '\n':
 sb.append("\\n");
 break;
 case '\r':
 sb.append("\\r");
 break;
 case '\t':
 sb.append("\\t");
 break;
 case '/':
 sb.append("\\/");
 break;
 default:
 if (ch >= '\u0000' && ch <= '\u001F') {
 String ss = Integer.toHexString(ch);
 sb.append("\\u");
 for (int k = 0; k < 4 - ss.length(); k++) {
 sb.append('0');
 }
 sb.append(ss.toUpperCase());
 } else {
 sb.append(ch);
 }
 }
 }
 return sb.toString();
 }
 
 public static String bean2json(Object bean) {
 StringBuilder json = new StringBuilder();
 json.append("{");
 PropertyDescriptor[] props = null;
 try {
 props = Introspector.getBeanInfo(bean.getClass(), Object.class)
 .getPropertyDescriptors();
 } catch (IntrospectionException e) {
 }
 if (props != null) {
 for (int i = 0; i < props.length; i++) {
 try {
 String name = object2json(props[i].getName());
 String value = object2json(props[i].getReadMethod().invoke(
 bean));
 json.append(name);
 json.append(":");
 json.append(value);
 json.append(",");
 } catch (Throwable e) {
 }
 }
 json.setCharAt(json.length() - 1, '}');
 } else {
 json.append("}");
 }
 return json.toString();
 }
 
 
 }

**2.1、首先在我们的constant目录底下新建一个SystemStaticConst.java通用常量类，主要用于存放常用静态常量。**

package com.mongo.common.base.constant;
    /**
     * Created by Administrator on 2017/8/7 0007.
     */
    public class SystemStaticConst {
    
        public final static String RESULT = "success";
        public final static boolean SUCCESS = true;
        public final static boolean FAIL = false;
        public final static String MSG = "msg";
    
    }

**  2.2、接着编写我们的通用实体类、通用实体类主要包含Pagination（分页实体类）、QueryBase（查询实体类）、QueryField（实体Bean上注解查询的类）、QueryType（实体上查询的枚举类型）。**

2.2.1、Pagination：主要是对页面的分页进行封装，代码如下：

package com.mongo.common.base.entity;
 
 import java.util.List;
 
 public class Pagination<T> {
 
 public Pagination(){
 super();
 }
 
 public Pagination(Integer currentPage,Integer totalPage,Integer totalNumber){
 this.currentPage = currentPage;
 this.totalPage = totalPage;
 this.totalNumber = totalNumber;
 }
 
 /**
 * 每页显示条数
 */
 private Integer pageSize = 8;
 
 /**
 * 当前页
 */
 private Integer currentPage = 1;
 
 /**
 * 总页数
 */
 private Integer totalPage = 1;
 
 /**
 * 查询到的总数据量
 */
 private Integer totalNumber = 0;
 
 /**
 * 数据集
 */
 private List items;
 
 public Integer getPageSize() {
 return pageSize;
 }
 
 public void setPageSize(Integer pageSize) {
 this.pageSize = pageSize;
 }
 
 public Integer getCurrentPage() {
 return currentPage;
 }
 
 public void setCurrentPage(Integer currentPage) {
 this.currentPage = currentPage;
 }
 
 public Integer getTotalPage() {
 return totalPage;
 }
 
 public void setTotalPage(Integer totalPage) {
 this.totalPage = totalPage;
 }
 
 public Integer getTotalNumber() {
 return totalNumber;
 }
 
 public void setTotalNumber(Integer totalNumber) {
 this.totalNumber = totalNumber;
 }
 
 public List getItems() {
 return items;
 }
 
 public void setItems(List items) {
 this.items = items;
 }
 
 /**
 * 处理查询后的结果数据
 *
 * @param items 查询结果集
 */
 public void build(List items) {
 this.setItems(items);
 int count = this.getTotalNumber();
 int divisor = count / this.getPageSize();
 int remainder = count % this.getPageSize();
 this.setTotalPage(remainder == 0 ? divisor == 0 ? 1 : divisor : divisor + 1);
 }
 }

2.2.2、QueryBase：实现对查询实体的封装，代码如下：

package com.mongo.common.base.entity;
    
    public class QueryBase {
    
        /**
         * 页数
         */
        protected int page;
    
        /**
         * 获取一页行数
         * */
        protected int limit;
    
    
        public int getPage() {
            return page;
        }
    
        public void setPage(int page) {
            this.page = page;
        }
    
        public int getLimit() {
            return limit;
        }
    
        public void setLimit(int limit) {
            this.limit = limit;
        }
    }

2.2.3、QueryType：查询类型的媒介类，主要用于确定那些字段需要在查询的时候使用到，也许在这里大家可能还不是很明白，等到下一章我们开始编写具体的业务实现的时候，大家就会明白该枚举的作用。

package com.mongo.common.base.entity;
 
 /**
 * Created by Administrator on 2018/3/30 0030.
 */
 
 import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.util.StringUtils;
 
 import java.lang.reflect.Field;
 import java.util.List;
 
 /**
 * 
 * 查询类型的媒介类 
 * 目前有支持三种类型： 
 * 1. equals：相等
 * 2. like:mongodb的like查询
 * 3. in:用于列表的in类型查询
 * 
 *
 */
 public enum QueryType {
 EQUALS {
 @Override
 public Criteria buildCriteria(QueryField queryFieldAnnotation, Field field, Object value) {
 if (check(queryFieldAnnotation, field, value)) {
 String queryField = getQueryFieldName(queryFieldAnnotation, field);
 return Criteria.where(queryField).is(value.toString());
 }
 return new Criteria();
 }
 },
 LIKE {
 @Override
 public Criteria buildCriteria(QueryField queryFieldAnnotation, Field field, Object value) {
 if (check(queryFieldAnnotation, field, value)) {
 String queryField = getQueryFieldName(queryFieldAnnotation, field);
 return Criteria.where(queryField).regex(value.toString());
 }
 return new Criteria();
 }
 },
 IN {
 @Override
 public Criteria buildCriteria(QueryField queryFieldAnnotation, Field field, Object value) {
 if (check(queryFieldAnnotation, field, value)) {
 if (value instanceof List) {
 String queryField = getQueryFieldName(queryFieldAnnotation, field);
 // 此处必须转型为List，否则会在in外面多一层[]
 return Criteria.where(queryField).in((List<?>)value);
 }
 }
 return new Criteria();
 }
 };
 
 private static boolean check(QueryField queryField, Field field, Object value) {
 return !(queryField == null || field == null || value == null);
 }
 
 public abstract Criteria buildCriteria(QueryField queryFieldAnnotation, Field field, Object value);
 
 /**
 * 如果实体bean的字段上QueryField注解没有设置attribute属性时，默认为该字段的名称
 *
 * @param queryField
 * @param field
 * @return
 */
 private static String getQueryFieldName(QueryField queryField, Field field) {
 String queryFieldValue = queryField.attribute();
 if (!StringUtils.hasText(queryFieldValue)) {
 queryFieldValue = field.getName();
 }
 return queryFieldValue;
 }
 }

2.2.4、QueryField：用于实体Bean的属性上的注解，注解有两个属性可以设置，type表示查询类似，默认为equals，此块也是等到下一章具体使用的时候再和大家详细介绍，代码如下所示：

package com.mongo.common.base.entity;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
 * 
 * 用于实体Bean的属性上的注解，注解有两个属性可以设置，type表示查询类似，默认为equals 
 * attribute表示要查询的属性，默认为空串，在使用时如果为空串，则默认为实体Bean字段的名称
 * 
 *
 */
 @Target(ElementType.FIELD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface QueryField {
 QueryType type() default QueryType.EQUALS;
 String attribute() default "";
 }

**2.3、接着再我们的base的dao目录底下编写我们的dao层的数据库抽象实现类（MongodbBaseService），代码如下所示：**

package com.mongo.common.base.dao;
 
 
 import com.mongo.common.base.entity.Pagination;
 import com.mongo.common.base.entity.QueryBase;
 import com.mongo.common.base.entity.QueryField;
 import com.mongo.common.util.common.CommonUtil;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.ParameterizedType;
 import java.util.List;
 
 /*
 * 类描述：
 * @auther linzf
 * @create 2018/3/30 0030 
 */
 public abstract class MongodbBaseDao<T,Q extends QueryBase>{
 
 @Autowired
 @Qualifier("mongoTemplate")
 protected MongoTemplate mongoTemplate;
 
 //保存一个对象到mongodb
 public T save(T bean) {
 mongoTemplate.save(bean);
 return bean;
 }
 
 // 根据id删除对象
 public void deleteById(T t) {
 mongoTemplate.remove(t);
 }
 
 // 根据对象的属性删除
 public void deleteByCondition(T t) {
 Query query = buildBaseQuery(t);
 mongoTemplate.remove(query, getEntityClass());
 }
 
 // 通过条件查询更新数据
 public void update(Query query, Update update) {
 mongoTemplate.updateMulti(query, update, this.getEntityClass());
 }
 
 // 根据id进行更新
 public void updateById(String id, T t) {
 Query query = new Query();
 query.addCriteria(Criteria.where("id").is(id));
 Update update = buildBaseUpdate(t);
 update(query, update);
 }
 
 // 通过条件查询实体(集合)
 public List<T> find(Query query) {
 return mongoTemplate.find(query, this.getEntityClass());
 }
 
 public List<T> findByCondition(T t) {
 Query query = buildBaseQuery(t);
 return mongoTemplate.find(query, getEntityClass());
 }
 
 // 通过一定的条件查询一个实体
 public T findOne(Query query) {
 return mongoTemplate.findOne(query, this.getEntityClass());
 }
 
 
 // 通过ID获取记录
 public T get(String id) {
 return mongoTemplate.findById(id, this.getEntityClass());
 }
 
 // 通过ID获取记录,并且指定了集合名(表的意思)
 public T get(String id, String collectionName) {
 return mongoTemplate.findById(id, this.getEntityClass(), collectionName);
 }
 
 /**
 * 通过条件查询,查询分页结果
 */
 public Pagination<T> findByPage(Q q) {
 Query query = buildBaseQuery(q);
 //获取总条数
 long totalCount = this.mongoTemplate.count(query, this.getEntityClass());
 //总页数
 int totalPage = (int) (totalCount/q.getLimit());
 int skip = (q.getPage()-1)*q.getLimit();
 Pagination<T> page = new Pagination(q.getPage(), totalPage, (int)totalCount);
 query.skip(skip);// skip相当于从那条记录开始
 query.limit(q.getLimit());// 从skip开始,取多少条记录
 List<T> data = this.find(query);
 page.build(data);//获取数据
 return page;
 }
 
 /**
 * 根据注解构建Query查询条件
 * @param q
 * @return
 */
 public Query buildBaseQuery(Q q){
 Query query = new Query();
 
 Field[] fields = q.getClass().getDeclaredFields();
 for (Field field : fields) {
 field.setAccessible(true);
 try {
 Object value = field.get(q);
 if (value != null&&!value.equals("")) {
 QueryField queryField = field.getAnnotation(QueryField.class);
 if (queryField != null) {
 if(value instanceof String){
 query.addCriteria(queryField.type().buildCriteria(queryField, field, value));
 }else{
 query.addCriteria(queryField.type().buildCriteria(queryField, field, value));
 }
 }
 }
 } catch (IllegalArgumentException e) {
 e.printStackTrace();
 } catch (IllegalAccessException e) {
 e.printStackTrace();
 }
 }
 return query;
 }
 
 // 根据vo构建查询条件Query
 private Query buildBaseQuery(T t) {
 Query query = new Query();
 
 Field[] fields = t.getClass().getDeclaredFields();
 for (Field field : fields) {
 field.setAccessible(true);
 try {
 Object value = field.get(t);
 if (value != null) {
 QueryField queryField = field.getAnnotation(QueryField.class);
 if (queryField != null) {
 query.addCriteria(queryField.type().buildCriteria(queryField, field, value));
 }
 }
 } catch (IllegalArgumentException e) {
 e.printStackTrace();
 } catch (IllegalAccessException e) {
 e.printStackTrace();
 }
 }
 return query;
 }
 
 private Update buildBaseUpdate(T t) {
 Update update = new Update();
 
 Field[] fields = t.getClass().getDeclaredFields();
 for (Field field : fields) {
 field.setAccessible(true);
 try {
 Object value = field.get(t);
 if (value != null) {
 update.set(field.getName(), value);
 }
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 return update;
 }
 
 // 获取需要操作的实体类class
 @SuppressWarnings("unchecked")
 protected Class<T> getEntityClass() {
 return ((Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
 }
 
 protected String getCollection(){
 String [] collections = getEntityClass().toString().split("\\.");
 return CommonUtil.toFirstCharLowerCase(collections[collections.length-1]);
 }
 
 public MongoTemplate getMongoTemplate() {
 return mongoTemplate;
 }
 }

**2.4、接着再我们的base的service目录底下编写我们的service层的业务抽象实现类（** **MongodbBaseDao），代码如下所示：**

package com.mongo.common.base.service;
 
 
 import com.mongo.common.base.dao.MongodbBaseDao;
 import com.mongo.common.base.entity.Pagination;
 import com.mongo.common.base.entity.QueryBase;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
 
 import java.util.List;
 
 public abstract class MongodbBaseService<T,Q extends QueryBase> {
 
 protected abstract MongodbBaseDao<T,Q> getDao();
 
 //保存一个对象到mongodb
 public T save(T bean) {
 getDao().save(bean);
 return bean;
 }
 
 // 根据id删除对象
 public void deleteById(T t) {
 getDao().deleteById(t);
 }
 
 /**
 * 功能描述：批量删除数据
 * @param entityList
 * @return
 */
 public boolean removeBath(List<T> entityList) throws Exception{
 for(T t:entityList){
 deleteById(t);
 }
 return true;
 }
 
 // 根据对象的属性删除
 public void deleteByCondition(T t) {
 getDao().deleteByCondition(t);
 }
 
 // 通过条件查询更新数据
 public void update(Query query, Update update){
 getDao().update(query,update);
 }
 
 // 根据id进行更新
 public void updateById(String id, T t){
 getDao().updateById(id,t);
 }
 
 // 通过条件查询实体(集合)
 public List<T> find(Query query) {
 return getDao().find(query);
 }
 
 public List<T> findByCondition(T t){
 return getDao().findByCondition(t);
 }
 
 public T findOne(Query query){
 return getDao().findOne(query);
 }
 
 // 通过ID获取记录
 public T get(String id){
 return getDao().get(id);
 }
 
 // 通过ID获取记录,并且指定了集合名(表的意思)
 public T get(String id, String collectionName){
 return getDao().get(id,collectionName);
 }
 
 
 /**
 * 通过条件查询,查询分页结果
 */
 public Pagination<T> findByPage(Q q){
 return getDao().findByPage(q);
 }
 
 }

**  2.5、接着再我们的base的controller目录底下编写我们的controller层的抽象实现类（** **MongodbBaseController），代码如下所示：**

package com.mongo.common.base.controller;
 
 
 import com.mongo.common.base.constant.SystemStaticConst;
 import com.mongo.common.base.entity.QueryBase;
 import com.mongo.common.base.service.MongodbBaseService;
 import com.mongo.common.util.common.CommonUtil;
 import com.mongo.common.util.json.JsonHelper;
 import org.springframework.http.MediaType;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 
 import java.lang.reflect.ParameterizedType;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 public abstract class MongodbBaseController<T,Q extends QueryBase> {
 
 protected abstract MongodbBaseService<T,Q> getService();
 
 /**添加页面路径*/
 public final static String ADDPAGE = "/add";
 /**修改页面路径*/
 public final static String UPDATEPAGE = "/update";
 
 /**
 * Controller基路径
 * */
 protected String basePath;
 
 /**抽象方法，获取页面基路径
 * @throws Exception */
 protected String getPageBaseRoot() throws Exception{
 if(basePath==null){
 basePath = this.getClass().getName();
 Pattern p=Pattern.compile(".[a-z|A-z]+.controller.[a-z|A-z]+Controller");
 Matcher m=p.matcher(basePath);
 if(m.find()){
 basePath = m.group();
 basePath = basePath.substring(1, basePath.length()-10);
 basePath = basePath.replace(".", "/");
 basePath = basePath.replace("/controller/", "/");
 basePath = CommonUtil.toFirstCharLowerCase(basePath);
 basePath = basePath.substring(0,basePath.lastIndexOf("/")+1)+CommonUtil.toFirstCharLowerCase(basePath.substring(basePath.lastIndexOf("/")+1));
 }
 else{
 throw new Exception("获取页面基路径失败");
 }
 }
 return basePath;
 }
 
 /**
 * 功能描述：直接跳转到更新数据的页面
 * @param id
 * @return
 */
 @RequestMapping(value = "/updatePage",method = RequestMethod.GET,produces = MediaType.APPLICATION_JSON_VALUE)
 public String updatePage(String id,Model model) throws Exception{
 T entity = getService().get(id);
 model.addAttribute("entity",entity);
 return getPageBaseRoot()+UPDATEPAGE;
 }
 
 /** 跳转到添加对象页面
 * @throws Exception */
 @RequestMapping(value="/addPage")
 public String addPage() throws Exception{
 return getPageBaseRoot()+ADDPAGE;
 }
 
 /**
 * 功能描述：保存数据字典数据
 * @param entity
 * @return
 */
 @RequestMapping(value = "/save",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
 @ResponseBody
 public Map<String,Object> save(T entity) throws Exception{
 entity = getService().save(entity);
 Map<String,Object> result = new HashMap<String, Object>();
 if(entity!=null){
 result.put(SystemStaticConst.RESULT,SystemStaticConst.SUCCESS);
 result.put(SystemStaticConst.MSG,"增加数据成功！");
 result.put("entity",entity);
 }else{
 result.put(SystemStaticConst.RESULT,SystemStaticConst.FAIL);
 result.put(SystemStaticConst.MSG,"增加数据失败！");
 }
 return result;
 }
 
 
 /**
 * 功能描述：更新数据字典数据
 * @param entity
 * @return
 */
 @RequestMapping(value = "/update",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
 @ResponseBody
 public Map<String,Object> update(String id,T entity) throws Exception{
 Map<String,Object> result = new HashMap<String, Object>();
 try{
 getService().updateById(id,entity);
 result.put(SystemStaticConst.RESULT,SystemStaticConst.SUCCESS);
 result.put(SystemStaticConst.MSG,"更新数据成功！");
 result.put("entity",entity);
 }catch(Exception e){
 result.put(SystemStaticConst.RESULT,SystemStaticConst.FAIL);
 result.put(SystemStaticConst.MSG,"更新数据失败！");
 }
 return result;
 }
 
 /**
 * 功能描述：实现根据ID来删除数据
 * @param entity
 * @return
 */
 @RequestMapping(value = "/remove",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
 @ResponseBody
 public Map<String,Object> remove(T entity) throws Exception{
 Map<String,Object> result = new HashMap<String, Object>();
 getService().deleteById(entity);
 result.put(SystemStaticConst.RESULT,SystemStaticConst.SUCCESS);
 result.put(SystemStaticConst.MSG,"删除数据成功！");
 return result;
 }
 
 /**
 * 功能描述：实现批量删除数据字典的记录
 * @param json
 * @return
 */
 @RequestMapping(value = "/removeBath",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
 @ResponseBody
 public Map<String,Object> removeBath(String json) throws Exception{
 Map<String,Object> result = new HashMap<String, Object>();
 getService().removeBath((List<T>) JsonHelper.toList(json,(Class <T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]));
 result.put(SystemStaticConst.RESULT,SystemStaticConst.SUCCESS);
 result.put(SystemStaticConst.MSG,"删除数据成功！");
 return result;
 }
 
 /**
 * 功能描述：判断当前的字典元素是否已经存在
 * @param entity
 * @return
 */
 @RequestMapping(value = "/isExist",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_VALUE)
 @ResponseBody
 public Map<String,Object> isExist(T entity){
 Map<String,Object> result = new HashMap<String, Object>();
 if(getService().findByCondition(entity).size()>0){
 result.put("valid",false);
 }else{
 result.put("valid",true);
 }
 return result;
 }
 
 
 
 }

到此我们完成了我们的swagger和抽象实现类的实现，到本章为止大家虽然可以运行起来项目，可是是看不到实际的效果的，在下一章我们将集成我们的security实现用户的登陆功能。

到此为止的GitHub项目地址：[https://github.com/185594-5-27/csdn/tree/master-base-3][https_github.com_185594-5-27_csdn_tree_master-base-3]

上一篇文章地址：[ 基于spring boot和mongodb打造一套完整的权限架构（二）【MAVEN依赖以及相应配置】][_spring boot_mongodb_MAVEN]

下一篇文章地址：[ 基于spring boot和mongodb打造一套完整的权限架构（四）【完全集成security】][_spring boot_mongodb_security]

QQ交流群：578746866

[20180416094839596]: /images/20220527/72e417ebf45447adb7fb689893cdd980.png
[https_github.com_185594-5-27_csdn_tree_master-base-3]: https://github.com/185594-5-27/csdn/tree/master-base-3
[_spring boot_mongodb_MAVEN]: https://blog.csdn.net/linzhefeng89/article/details/79930655
[_spring boot_mongodb_security]: https://blog.csdn.net/linzhefeng89/article/details/79959325