admin管理员组文章数量:1574495
效果图
相关依赖
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
常见异常
解决办法: 把swagger的版本改为2.9.2或者其他版本试试
相关配置
package com.yymt.startalk_yyt.common;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import io.swagger.annotations.ApiOperation;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.ParameterBuilder;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.schema.ModelRef;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Parameter;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
@Bean
public Docket createRestApi() {
// 添加head参数配置start
ParameterBuilder tokenPar = new ParameterBuilder();
List<Parameter> pars = new ArrayList<>();
tokenPar.name("Authorization").description("令牌").modelRef(new ModelRef("string")).parameterType("header")
.required(false).build();
pars.add(tokenPar.build());
return new Docket(DocumentationType.SWAGGER_2).enable(true) // 为接口安全，不要注释本条
.apiInfo(apiInfo()).select()
// 加了ApiOperation注解的类，生成接口文档
.apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
// 包下的类，生成接口文档
//.apis(RequestHandlerSelectors.basePackage("com.yymt.modules.controller.applet"))
//.apis(RequestHandlerSelectors.basePackage("com.yymt")).paths(PathSelectors.any()).build()
.build().globalOperationParameters(pars);
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder().title("憶源科技 星语 即时通讯-后台管理端文档")
//.description("所有列表全局参数{\"page\":\"页码\",\"limit\":\"每页显示的条数\",\"order\":\"ASC OR DESC\",\"sidx\"\":\"已哪列为排序\"}\n参数可传可不传，page默认为第一页，limit默认10条，默认排序规则，ID 升序")
.description("").termsOfServiceUrl("http://www.yymt").version("1.0.0").build();
}
}
controller
package com.yymt.startalk_yyt.controller;
import com.yymt.startalk_yyt.common.R;
import com.yymt.startalk_yyt.service.BeanUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
@RestController
@RequestMapping("startalk/user")
@Api(tags = "测试用例")
public class ControllerBean {
@Autowired
BeanUserService beanUserService;
@PostMapping("/getById")
@ApiOperation(value = "根据id查询")
public R info(
@ApiParam(value = "数据格式：json格式，所需字段，id:编号)")
@RequestBody Map<String, Object> params) {
return beanUserService.selectId(params);
}
@PostMapping("/add")
@ApiOperation("新增")
public R addActivity(
@ApiParam("请求数据格式：json格式，所需字段：id：活动名称，user_name：用户名，pass_word：密码")
@RequestBody Map<String, Object> params) {
return beanUserService.addOrUpdate(params);
}
@PostMapping("/update")
@ApiOperation(value = "修改")
public R updateActivity(
@ApiParam("请求数据格式：json格式，所需字段：id：活动名称，user_name：用户名，pass_word：密码")
@RequestBody Map<String, Object> params) {
return beanUserService.addOrUpdate(params);
}
@PostMapping("/deleteById")
@ApiOperation(value = "根据id删除")
public R deleteActivity(
@ApiParam(value = "数据格式：json格式，所需字段，id:编号")
@RequestBody Map<String, Object> params) {
return beanUserService.deleteById(params);
}
@PostMapping("/list")
@ApiOperation("列表")
public R list() {
return beanUserService.queryList();
}
}
service
package com.yymt.startalk_yyt.service;
import com.yymt.startalk_yyt.common.R;
import java.util.Map;
public interface BeanUserService {
/**
* @Description: 根据id查询
* @Param [params]
* @return com.yymt.startalk_yytmon.R
* @author pengyao
* @date 2020-07-25 9:58
*/
R selectId(Map<String, Object> params);
/**
* @Description: 根据id删除
* @Param [params]
* @return com.yymt.startalk_yytmon.R
* @author pengyao
* @date 2020-07-25 11:50
*/
R deleteById(Map<String, Object> params);
/**
* @Description: 新增或者修改
* @Param [params]
* @return com.yymt.startalk_yytmon.R
* @author pengyao
* @date 2020-07-25 13:10
*/
R addOrUpdate(Map<String, Object> params);
/**
* @Description: 列表
* @Param [params]
* @return com.yymt.startalk_yytmon.R
* @author pengyao
* @date 2020-07-25 13:23
*/
R queryList();
}
impl
package com.yymt.startalk_yyt.service.impl;
import com.yymt.startalk_yyt.common.ConvertUtil;
import com.yymt.startalk_yyt.common.PageUtils;
import com.yymt.startalk_yyt.common.R;
import com.yymt.startalk_yyt.entity.BeanUser;
import com.yymt.startalk_yyt.mapper.BeanUserMapper;
import com.yymt.startalk_yyt.service.BeanUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
@Service
public class BeanUserServiceImpl implements BeanUserService {
@Autowired
BeanUserMapper beanUserMapper;
/**
* @param params
* @return com.yymt.startalk_yytmon.R
* @Description: 根据id查询
* @Param [params]
* @author pengyao
* @date 2020-07-25 9:58
*/
@Override
public R selectId(Map<String, Object> params) {
int id = ConvertUtil.parseInt(params.get("id"));
BeanUser beanUser = beanUserMapper.selectId(id);
return R.ok().put("data", beanUser);
}
/**
* @param params
* @return com.yymt.startalk_yytmon.R
* @Description: 根据id删除
* @Param [params]
* @author pengyao
* @date 2020-07-25 11:50
*/
@Override
public R deleteById(Map<String, Object> params) {
int id = ConvertUtil.parseInt(params.get("id"));
beanUserMapper.deleteById(id);
return R.ok();
}
/**
* @param params
* @return com.yymt.startalk_yytmon.R
* @Description: 新增或者修改
* @Param [params]
* @author pengyao
* @date 2020-07-25 13:10
*/
@Override
public R addOrUpdate(Map<String, Object> params) {
int id = ConvertUtil.parseInt(params.get("id"));
String user_name = ConvertUtil.objToStrConverNull(params.get("user_name"));
String pass_word = ConvertUtil.objToStrConverNull(params.get("pass_word"));
BeanUser beanUser = new BeanUser();
beanUser.setId(id);
beanUser.setUser_name(user_name);
beanUser.setPass_word(pass_word);
BeanUser beanUser0 = beanUserMapper.selectId(id);
if (beanUser0 != null) {// 修改
beanUserMapper.UpdateBean(beanUser);
} else { // 新增
beanUserMapper.insertBean(beanUser);
}
return R.ok();
}
/**
* @param params
* @return com.yymt.startalk_yytmon.R
* @Description: 列表
* @Param [params]
* @author pengyao
* @date 2020-07-25 13:23
*/
@Override
public R queryList() {
List<Map<String, Object>> list = beanUserMapper.queryList();
return R.ok().put("data", list);
}
}
mapper
package com.yymt.startalk_yyt.mapper;
import com.yymt.startalk_yyt.entity.BeanUser;
import org.apache.ibatis.annotations.*;
import java.util.List;
import java.util.Map;
//指定这是一个操作数据库的mapper
@Mapper
public interface BeanUserMapper {
//查询
@Select("select * from bean_user where id=#{id}")
public BeanUser selectId(Integer id);
//删除
@Delete("delete from bean_user where id=#{id}")
public int deleteById(Integer id);
//插入
@Insert("insert into bean_user(id,user_name,pass_word) values(#{id},#{user_name},#{pass_word})")
public int insertBean(BeanUser beanUser);
//修改
@Update("update bean_user set user_name=#{user_name},pass_word=#{pass_word} where id=#{id}")
public int UpdateBean(BeanUser beanUser);
//列表
@Select("select * from bean_user")
List<Map<String, Object>> queryList();
}
BeanUser
package com.yymt.startalk_yyt.entity;
public class BeanUser {
private Integer id;
private String user_name;
private String pass_word;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public String getPass_word() {
return pass_word;
}
public void setPass_word(String pass_word) {
this.pass_word = pass_word;
}
}
R
package com.yymt.startalk_yyt.common;
import java.util.HashMap;
import java.util.Map;
/**
* 返回数据
*/
public class R extends HashMap<String, Object> {
private static final long serialVersionUID = 1L;
public R() {
put("code", 0);
put("msg", "success");
}
public static R error() {
return error(ResultEnum.ERROR);
}
public static R error(String msg) {
R r = new R();
r.put("code", 1);
r.put("msg", msg);
return r;
}
public static R error(ResultEnum resultEnum) {
R r = new R();
r.put("code", resultEnum.getCode());
r.put("msg", resultEnum.getMsg());
return r;
}
public static R ok(String msg) {
R r = new R();
r.put("msg", msg);
return r;
}
public static R ok(Map<String, Object> map) {
R r = new R();
r.putAll(map);
return r;
}
public static R ok() {
return new R();
}
@Override
public R put(String key, Object value) {
super.put(key, value);
return this;
}
public static R error(int code,String msg) {
R r = new R();
r.put("code", code);
r.put("msg", msg);
return r;
}
}
ConvertUtil
package com.yymt.startalk_yyt.common;
import net.sf.ezmorph.object.DateMorpher;
import net.sf.json.JSONObject;
import net.sf.json.util.JSONUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.URLEncoder;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* @describe:转换工具类
* @author xiaojin
* @date 2019年10月12日 上午9:49:05
**/
public class ConvertUtil {
private static final Logger log = LoggerFactory.getLogger(ConvertUtil.class);
/**
*
* @describe:获取上传路径
* @author: xiaojin
*/
public static String getUploadPath() {
Calendar cal = Calendar.getInstance();
int month = cal.get(Calendar.MONTH) + 1;
int year = cal.get(Calendar.YEAR);
return "/upload/" + year + "/" + month + "/";
}
public static int getFileType(String fileName) {
int fileType = 0;
String suffixName = fileName.substring(fileName.indexOf("."), fileName.length());
if (suffixName.equalsIgnoreCase(".JPG") || suffixName.equalsIgnoreCase(".JPEG")
|| suffixName.equalsIgnoreCase(".PNG") || suffixName.equalsIgnoreCase(".GIF")
|| suffixName.equalsIgnoreCase(".BMP")) {
fileType = 1;
} else if (suffixName.equalsIgnoreCase(".AVI") || suffixName.equalsIgnoreCase(".MP4")
|| suffixName.equalsIgnoreCase(".MOV") || suffixName.equalsIgnoreCase(".ASF")
|| suffixName.equalsIgnoreCase(".RM")) {
fileType = 2;
} else {
fileType = 3;
}
return fileType;
}
public static void deleteFile(String uploadPath, String filePath) {
File file = new File(uploadPath + filePath);
file.delete();
}
/**
* @describe：生成指定位数数字随机数
*/
public synchronized static String getRandomNumber(int lengt) {
String str = "0123456789";
Random random = new Random();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < lengt; i++) {
int number = random.nextInt(10);
sb.append(str.charAt(number));
}
return sb.toString();
}
/**
* @describe：生成微信支付订单号
*/
public synchronized static String getWechatOrdersNo() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String timeStr = sdf.format(new Date());
String ordersNo = "wx";
ordersNo = ordersNo + timeStr + getRandomNumber(10);
return ordersNo;
}
/**
* @describe：生成微信公众平台订单号
*/
public synchronized static String getOrdersNo() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String timeStr = sdf.format(new Date());
String ordersNo = timeStr + getRandomNumber(8);
return ordersNo;
}
/**
* @describe：生成制定位数的数字+大写字母的随机数
*/
public synchronized static String getRandomStr(int lengt) {
String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
Random random = new Random();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < lengt; i++) {
int number = random.nextInt(36);
sb.append(str.charAt(number));
}
return sb.toString();
}
/**
* @describe：生成制定位数的数字+大写字母的随机数
*/
public synchronized static String getRandomLower(int lengt) {
String str = "abcdefghijklmnopqrstuvwxyz0123456789";
Random random = new Random();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < lengt; i++) {
int number = random.nextInt(36);
sb.append(str.charAt(number));
}
return sb.toString();
}
public static Map<String, Object> getParams(Map<String, Object> params) {
int pageSize = 10;
if (params.get("pageSize") != null) {
pageSize = Integer.parseInt(String.valueOf(params.get("pageSize")));
}
int currPage = 1;
if (params.get("currPage") != null) {
currPage = Integer.parseInt(String.valueOf(params.get("currPage")));
}
params.put("index", (currPage - 1) * pageSize);
params.put("pageSize", pageSize);
params.put("currPage", currPage);
return params;
}
public static Map<String, Object> getParams_wangxin(Map<String, Object> params) {
int pageSize = 10;
if (params.get("pageSize") != null) {
pageSize = Integer.parseInt(String.valueOf(params.get("pageSize")));
}
int currPage = 1;
if (params.get("currPage") != null) {
currPage = Integer.parseInt(String.valueOf(params.get("currPage")));
}
// params.put("index", (currPage - 1) * pageSize);
params.put("pageSize", pageSize + "");
params.put("pageIndex", currPage + "");
params.put("curIndex", currPage + "");
return params;
}
public static Map<String, Object> getParams02(Map<String, Object> params) {
int pageSize = 10;
if (params.get("pageSize") != null) {
pageSize = Integer.parseInt(String.valueOf(params.get("pageSize")));
}
int currPage = 1;
if (params.get("currPage") != null) {
currPage = Integer.parseInt(String.valueOf(params.get("currPage")));
}
params.put("index", (currPage - 1) * pageSize);
params.put("limit", pageSize);
params.put("page", currPage);
return params;
}
public static JSONObject getParams(HttpServletRequest request) {
BufferedReader br = null;
StringBuilder sb = new StringBuilder("");
try {
br = request.getReader();
String str;
while ((str = br.readLine()) != null) {
sb.append(str);
}
br.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != br) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
String dateStr = sb.toString();
SensitiveWordUtils filter = new SensitiveWordUtils();
dateStr = filter.replaceSensitiveWord(dateStr, 2, "*");
JSONUtils.getMorpherRegistry().registerMorpher(new DateMorpher(new String[] { "yyyy-MM-dd HH:mm:ss" }));
return JSONObject.fromObject(dateStr);
}
/**
* String转换工具类：包含null对象，空字符串大小写"null"，空格，统一转成 ：null对象
*/
public static String objToStrConverNull(Object object) {
String string = null;
if (object == null) {
return string;
} else {
string = String.valueOf(object).trim();
if (string.length() == 0 || string.equalsIgnoreCase("null")) {
return null;
}
return string;
}
}
/**
* String转换工具类：包含null对象，空字符串大小写"null"，空格，统一转成 ：""对象
*/
public static String objToStrConverSpace(Object object) {
String string = "";
if (object == null) {
return string;
} else {
string = String.valueOf(object).trim();
if (string.length() == 0 || string.equalsIgnoreCase("null")) {
return "";
}
return string;
}
}
public static PageUtils getPageUtil(Map<String, Object> params, List<Map<String, Object>> list, int count) {
int pageSize = Integer.parseInt(String.valueOf(params.get("pageSize")));
int currPage = Integer.parseInt(String.valueOf(params.get("currPage")));
PageUtils page = new PageUtils(list, count, pageSize, currPage);
return page;
}
public static PageUtils getPageUtil(Map<String, Object> params, Object list, int count) {
int pageSize = Integer.parseInt(String.valueOf(params.get("pageSize")));
int currPage = Integer.parseInt(String.valueOf(params.get("currPage")));
PageUtils page = new PageUtils((List<?>) list, count, pageSize, currPage);
return page;
}
public static String addDateMinut(Date date, int hour) {
SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.HOUR, hour);// 24小时制
date = cal.getTime();
cal = null;
return format.format(date);
}
public static int parseInt(Object object) {
String string = objToStrConverNull(object);
Integer integer = 0;
if (string != null && string.length() <= 10) {
integer = Integer.parseInt(string);
}
return integer;
}
public static Integer parseIntNull(Object object) {
String string = objToStrConverNull(object);
Integer integer = null;
if (string != null && string.length() <= 10) {
integer = Integer.parseInt(string);
}
return integer;
}
public static long parseLong(Object object) {
String longStr = objToStrConverNull(object);
long l = 0;
if (longStr != null && longStr.length() <= 19) {
l = Long.parseLong(longStr);
}
return l;
}
public static double parseDouble(Object object) {
String string = objToStrConverNull(object);
double d = 0.00;
if (string != null) {
d = Double.parseDouble(string);
}
return d;
}
public static Date add(Date date, int type, int value) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(type, value);
return calendar.getTime();
}
/**
*
* @describe:Date 类型转 指定格式的字符串时间格式
*/
public static String dateConvert(Date date, String dateType) {
String string = null;
SimpleDateFormat sdf = new SimpleDateFormat(dateType);
string = sdf.format(date);
return string;
}
/**
*
* @describe:Date 类型转 指定格式的字符串时间格式
*/
public static Date dateConvert(String dateStr, String dateType) {
Date date = null;
try {
SimpleDateFormat sdf = new SimpleDateFormat(dateType);
date = sdf.parse(dateStr);
} catch (Exception e) {
e.printStackTrace();
}
return date;
}
public static String getCurrentYear() {
return dateConvert(new Date(), "yyyy");
}
public static String dateFormat1(Date date) {
return dateConvert(date, "yyyy-MM-dd");
}
public static double objToDoubleConvert(Object object) {
double d = 0.00d;
try {
if (object != null) {
String s = String.valueOf(object).trim();
if (s.length() > 0 && !s.equals("null")) {
DecimalFormat format = new DecimalFormat(",#.#");
d = format.parse(s).doubleValue();
BigDecimal bg = new BigDecimal(d);
return bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
} else {
return d;
}
} else {
return d;
}
} catch (Exception e) {
e.printStackTrace();
return d;
}
}
public static BigDecimal parseBigDecimal(Object str) {
String string = objToStrConverNull(str);
BigDecimal bd = new BigDecimal(0.00);
if (string != null) {
bd = new BigDecimal(string);
}
return bd;
}
public static BigDecimal parseBigDecimalNull(Object str) {
String string = objToStrConverNull(str);
BigDecimal bd = null;
if (string != null) {
bd = new BigDecimal(string);
}
return bd;
}
public static double parseDouble4Decimal(Object object) {
double d = 0.00000;
try {
String objStr = objToStrConverNull(object);
if (objStr != null) {
DecimalFormat df = new DecimalFormat("#.0000");
d = Double.valueOf(df.format(object));
}
} catch (NumberFormatException e) {
e.printStackTrace();
}
return d;
}
/**
*
* 对象转 double，如果转换对象为0.00则转为1.00
*/
public static double parseDouble1(Object object) {
double d = 1.00d;
try {
String objStr = objToStrConverNull(object);
if (objStr != null) {
d = Double.parseDouble(objStr);
if (d == 0.00) {
d = 1.00d;
}
}
} catch (NumberFormatException e) {
e.printStackTrace();
}
return d;
}
private static final double EARTH_RADIUS = 6371393; // 平均半径,单位：m；不是赤道半径。赤道为6378左右
/**
* @描述 反余弦进行计算
* @参数 [lat1, lng1, lat2, lng2]
* @返回值 double
* @创建时间 2019/3/13 20:31
**/
public static double getDistance(Double lat1, Double lng1, Double lat2, Double lng2) {
// 经纬度（角度）转弧度。弧度用作参数，以调用Math.cos和Math.sin
double radiansAX = Math.toRadians(lng1); // A经弧度
double radiansAY = Math.toRadians(lat1); // A纬弧度
double radiansBX = Math.toRadians(lng2); // B经弧度
double radiansBY = Math.toRadians(lat2); // B纬弧度
// 公式中“cosβ1cosβ2cos（α1-α2）+sinβ1sinβ2”的部分，得到∠AOB的cos值
double cos = Math.cos(radiansAY) * Math.cos(radiansBY) * Math.cos(radiansAX - radiansBX)
+ Math.sin(radiansAY) * Math.sin(radiansBY);
// System.out.println("cos = " + cos); // 值域[-1,1]
double acos = Math.acos(cos); // 反余弦值
// System.out.println("acos = " + acos); // 值域[0,π]
// System.out.println("∠AOB = " + Math.toDegrees(acos)); // 球心角 值域[0,180]
return EARTH_RADIUS * acos; // 最终结果
}
public static String parse2DecimalStr(Object object) {
double d = Double.parseDouble(String.valueOf(object));
DecimalFormat df = new DecimalFormat("#.00");
String string = String.valueOf(df.format(d));
return string;
}
/**
* 保留两位小数
*
* @param object
* @return
*/
public static double parse2Decimal(Object object) {
String string = objToStrConverNull(object);
double d = 0.00;
if (string != null) {
d = Double.parseDouble(parse2DecimalStr(string));
}
return d;
}
/**
* 保留BigDecimal类型的两位小数
*
* @param object
* @return
*/
public static BigDecimal parse2BigDecimal(Object object) {
String string = objToStrConverNull(object);
BigDecimal bd = new BigDecimal(0.00);
if (string != null) {
bd = new BigDecimal(string);
bd = bd.setScale(2, RoundingMode.HALF_UP);
}
return bd;
}
public static String getLinkByGet(String reqUrl, Map<String, Object> params) {
String prestr = "";
List<String> keys = new ArrayList<String>(params.keySet());
Collections.sort(keys);
for (int i = 0; i < keys.size(); i++) {
String key = keys.get(i);
String value = String.valueOf(params.get(key));
try {
value = URLEncoder.encode(value, "UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
if (i == keys.size() - 1) {// 拼接时，不包括最后一个&字符
prestr = prestr + key + "=" + value;
} else {
prestr = prestr + key + "=" + value + "&";
}
}
reqUrl = reqUrl + "?" + prestr;
return reqUrl;
}
/**
* String类型的转json对象
*
* @param result
* @return
*/
public static JSONObject fromObject(String result) {
JSONObject jsonObject = null;
if (result != null) {
jsonObject = JSONObject.fromObject(result);
}
return jsonObject;
}
}
ResultEnum
package com.yymt.startalk_yyt.common;
public enum ResultEnum {
NO_IMPLEMENT(-1, "接口尚未实现"),
SUCCESS(0, "成功"),
ERROR(500, "服务器异常，请联系管理员"),
REDIS_ERROR(501, "Redis服务异常"),
DATA_ALREADY_EXIST(100,"数据库中已存在该记录"),
DATA_NOT_EXIST(101,"数据不存在"),
DELETE_ERROR(102,"删除失败"),
ADD_ERROR(103,"添加失败"),
UPDATE_ERROR(104,"修改失败"),
MANAGE_ERROR(105,"操作失败"),
SUBMIT_ERROR(99,"审核失败"),
USERNAME_PASSWORD_ERROR(106,"账号或密码错误"),
USER_LOCKED(107,"账号已被锁定,请联系管理员"),
USER_AUTH_ERROR(108,"账户验证失败"),
NO_PERMISSION(109,"没有权限，请联系管理员授权"),
OLD_PASSWORD_MISTAKE(110,"原密码不正确"),
ADMIN_CANT_DELETE(111,"系统管理员不能删除"),
USER_CANT_DELETE(112,"当前用户不能删除"),
USER_NOT_EXIST(114,"用户不存在"),
USER_FORBID(115,"该用户账号被禁用"),
USER_DELETED(116,"账号被删除"),
USER_EXIST(117,"用户已存在"),
USER_PWD_ERROR(118,"新密码与确认密码不相同"),
UPDATE_PWD_FAIL(119,"修改密码失败"),
ACCOUNT_NOT_EXIST(120,"账号不存在"),
USERNAME_NULL(121,"请输入用户名"),
PASSWORD_NULL(122,"请输入密码"),
RESTRICT_LOGIN(123,"连续五次密码输入错误,请一小时后再登录"),
PERMISSION_MUST_CHOOSE(124,"请勾选功能权限"),
AUTH_LOGIN_ERROR(125,"授权登录失败"),
REGISTERED_FIRST(126,"请注册后再登录"),
MOBILE_IS_WRONG(127,"手机号有误"),
MOBILE_IS_UNMAP(128,"当前手机号与微信帐号不匹配"),
REGISTER_NOT_OPEN(129,"暂未开放注册"),
SENSITIVE_WORD(599, "您输入的信息中包含了违禁信息"),
INVALID_INPUT(600, "包含非法字符"),
PARAM_TYPE_ERROR(601, "参数类型错误"),
PARAM_BLANK(602, "参数为空"),
PARAM_NULL(603, "参数NULL"),
GET_PARAM_ERROR(604, "获取参数失败"),
VALIDATOR_NOT_PASS(605, "校验未通过"),
API_ONLY_MAP(606, "数据权限接口，只能是Map类型参数，且不能为NULL"),
VALIDATOR_CODE_MISTAKE(664, "验证码错误"),
VALIDATOR_CODE_SEND_ERROR(665, "发送验证码失败"),
VALIDATOR_CODE_INVALID(666, "验证码已失效"),
MENU_NOT_NULL(700, "菜单名称不能为空"),
PARENT_MENU_NOT_NULL(701, "上级菜单不能为空"),
MENU_URL_NOT_NULL(702, "菜单URL不能为空"),
PARENT_MENU_ONLY_CATALOG(702,"上级菜单只能为目录类型"),
PARENT_MENU_ONLY_MENU(703,"上级菜单只能为菜单类型"),
SYSTEM_MENU_CANT_DELETE(704,"系统菜单，不能删除"),
DELETE_CHILD_OR_BUTTON_FIRST(705,"请先删除子菜单或按钮"),
SYSTEM_COLUMN_CANT_UPDATE(706,"系统的栏目名称不能修改"),
SYSTEM_COLUMN_CANT_DELETE(707,"所选的数据中包含了系统的栏目，不能删除"),
DELETE_CHILD_DEPARTMENT_FIRST(710,"请先删除子部门"),
SCHEDULE_JOB_RUN_ERROR(800,"执行定时任务失败"),
SCHEDULE_JOB_CRON_ERROR(801,"获取定时任务CronTrigger出现异常"),
SCHEDULE_JOB_CREATE_ERROR(802,"创建定时任务失败"),
SCHEDULE_JOB_UPDATE_ERROR(803,"更新定时任务失败"),
SCHEDULE_JOB_RUN_NOW_ERROR(804,"立即执行定时任务失败"),
SCHEDULE_JOB_PAUSE_ERROR(805,"暂停定时任务失败"),
SCHEDULE_JOB_RESUME_ERROR(806,"恢复定时任务失败"),
SCHEDULE_JOB_DELETE_ERROR(807,"删除定时任务失败"),
UPLOAD_ERROR(900,"上传文件失败"),
UPLOAD_ERROR_CHECK_CONFIG(901,"上传文件失败，请检查配置信息"),
UPLOAD_ERROR_CHECK_QI_NIU(902,"上传文件失败，请核对七牛配置信息"),
UPLOAD_FILE_NOT_NULL(903,"上传文件不能为空"),
CHOOSE_FILE(904,"请选择文件"),
UPLOAD_DIR_NOT_EXIST(905,"上传目录不存在"),
UPLOAD_DIR_ERROR(906,"文件类型错误"),
UPLOAD_FILE_SIZE_LIMIT(907,"上传文件大小超过限制"),
/* token */
AUTH_TOKEN_INVALID(1000, "token失效，请重新登录"),
AUTH_TOKEN_NULL(1001, "token不能为空"),
TOKEN_IS_NULL(1002, "您尚未登录,请登录后在操作"),
TOKEN_USERNAME_IS_NOT_EXIT(1003, "访问令牌异常或访问令牌已过期,请重新登录"),
TOKEN_FAIL(1004, "访问令牌错误"),
REMOTE_LOGIN(1005, "您的账号在异地登录，您已被迫下线"),
LOCATION_NULL(2000,"未获取到您的当前位置"),
DATA_NOT_YOURS(2100,"此公厕不是您共享的，不能修改"),
DATA_NOT_YOURS_DEL(2101,"此公厕不是您共享的，不能删除"),
DATA_DEL_ERROR_STATUS(2102,"此公厕不处于审核通过状态，不能删除"),
/* 信息发布系统 */
CONTENT_PUBLISHED(4501,"内容已分发，不可修改"),
FORMAT_ALREADY_EXIST(100,"已存在格式"),
ORDER_ERROR_NOKUCUN(4600,"库存不足"),
ORDER_ERROR_NOTTIME(4601,"活动结束"),
ORDER_ERROR_NOTEXSIT(4602,"订单不存在"),
HTTP_TIME_OUT(3001,"请求超时"),
FINAL_ERROR(999999999,"终极错误");
private final Integer code;
private final String msg;
ResultEnum(Integer code, String msg) {
this.code = code;
this.msg = msg;
}
public Integer getCode() {
return code;
}
public String getMsg() {
return msg;
}
}
SensitiveWordUtils
package com.yymt.startalk_yyt.common;
import org.apache.log4j.Logger;
import org.springframework.core.io.ClassPathResource;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;
/**
* @Description: 敏感词过滤
* @Project：test
* @Author : chenming
* @Date ： 2014年4月20日 下午4:17:15
* @version 1.0
*/
public class SensitiveWordUtils {
private final static Logger log= Logger.getLogger(SensitiveWordUtils.class);
@SuppressWarnings("rawtypes")
private static Map sensitiveWordMap = null;
public static int minMatchTYpe = 1; //最小匹配规则
public static int maxMatchType = 2; //最大匹配规则
private static String ENCODING = "utf-8"; //字符编码
static {
try {
//读取敏感词库
Set<String> keyWordSet = readSensitiveWordFile();
System.out.println("====================成功加载敏感词:"+keyWordSet.size()+"个");
//将敏感词库加入到HashMap中
addSensitiveWordToHashMap(keyWordSet);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型：<br>
* @author chenming
* @date 2014年4月20日 下午3:04:20
* @param keyWordSet 敏感词库
* @version 1.0
*/
private static void addSensitiveWordToHashMap(Set<String> keyWordSet) {
sensitiveWordMap = new HashMap(keyWordSet.size()); //初始化敏感词容器，减少扩容操作
String key = null;
Map nowMap = null;
Map<String, String> newWorMap = null;
//迭代keyWordSet
Iterator<String> iterator = keyWordSet.iterator();
while(iterator.hasNext()){
key = iterator.next(); //关键字
nowMap = sensitiveWordMap;
for(int i = 0 ; i < key.length() ; i++){
char keyChar = key.charAt(i); //转换成char型
Object wordMap = nowMap.get(keyChar); //获取
if(wordMap != null){ //如果存在该key，直接赋值
nowMap = (Map) wordMap;
}
else{ //不存在则，则构建一个map，同时将isEnd设置为0，因为他不是最后一个
newWorMap = new HashMap<String,String>();
newWorMap.put("isEnd", "0"); //不是最后一个
nowMap.put(keyChar, newWorMap);
nowMap = newWorMap;
}
if(i == key.length() - 1){
nowMap.put("isEnd", "1"); //最后一个
}
}
}
}
/**
* 读取敏感词库中的内容，将内容添加到set集合中
* @author chenming
* @date 2014年4月20日 下午2:31:18
* @return
* @version 1.0
* @throws Exception
*/
private static Set<String> readSensitiveWordFile() throws Exception{
Set<String> set = null;
ClassPathResource resource = new ClassPathResource("SensitiveWord.txt");
InputStream is = resource.getInputStream();
InputStreamReader read = new InputStreamReader(is,ENCODING);
try {
set = new HashSet<String>();
BufferedReader bufferedReader = new BufferedReader(read);
String txt = null;
while((txt = bufferedReader.readLine()) != null){ //读取文件，将文件内容放入到set中
set.add(txt);
}
} catch (Exception e) {
throw e;
}finally{
read.close(); //关闭文件流
}
return set;
}
/**
* 判断文字是否包含敏感字符
* @author chenming
* @date 2014年4月20日 下午4:28:30
* @param txt 文字
* @param matchType 匹配规则 1：最小匹配规则，2：最大匹配规则
* @return 若包含返回true，否则返回false
* @version 1.0
*/
public boolean isContaintSensitiveWord(String txt,int matchType){
boolean flag = false;
for(int i = 0 ; i < txt.length() ; i++){
int matchFlag = this.CheckSensitiveWord(txt, i, matchType); //判断是否包含敏感字符
if(matchFlag > 0){ //大于0存在，返回true
flag = true;
}
}
return flag;
}
/**
* 获取文字中的敏感词
* @author chenming
* @date 2014年4月20日 下午5:10:52
* @param txt 文字
* @param matchType 匹配规则 1：最小匹配规则，2：最大匹配规则
* @return
* @version 1.0
*/
public static Set<String> getSensitiveWord(String txt , int matchType){
Set<String> sensitiveWordList = new HashSet<String>();
for(int i = 0 ; i < txt.length() ; i++){
int length = CheckSensitiveWord(txt, i, matchType); //判断是否包含敏感字符
if(length > 0){ //存在,加入list中
sensitiveWordList.add(txt.substring(i, i+length));
i = i + length - 1; //减1的原因，是因为for会自增
}
}
return sensitiveWordList;
}
/**
* 替换敏感字字符
* @author chenming
* @date 2014年4月20日 下午5:12:07
* @param txt
* @param matchType
* @param replaceChar 替换字符，默认*
* @version 1.0
*/
public String replaceSensitiveWord(String txt,int matchType,String replaceChar){
String resultTxt = txt;
Set<String> set = getSensitiveWord(txt, matchType); //获取所有的敏感词
Iterator<String> iterator = set.iterator();
String word = null;
String replaceString = null;
while (iterator.hasNext()) {
word = iterator.next();
replaceString = getReplaceChars(replaceChar, word.length());
resultTxt = resultTxt.replaceAll(word, replaceString);
}
return resultTxt;
}
/**
* 获取替换字符串
* @author chenming
* @date 2014年4月20日 下午5:21:19
* @param replaceChar
* @param length
* @return
* @version 1.0
*/
private String getReplaceChars(String replaceChar,int length){
String resultReplace = replaceChar;
for(int i = 1 ; i < length ; i++){
resultReplace += replaceChar;
}
return resultReplace;
}
/**
* 检查文字中是否包含敏感字符，检查规则如下：<br>
* @author chenming
* @date 2014年4月20日 下午4:31:03
* @param txt
* @param beginIndex
* @param matchType
* @return，如果存在，则返回敏感词字符的长度，不存在返回0
* @version 1.0
*/
@SuppressWarnings({ "rawtypes"})
public static int CheckSensitiveWord(String txt,int beginIndex,int matchType){
boolean flag = false; //敏感词结束标识位：用于敏感词只有1位的情况
int matchFlag = 0; //匹配标识数默认为0
char word = 0;
Map nowMap = sensitiveWordMap;
for(int i = beginIndex; i < txt.length() ; i++){
word = txt.charAt(i);
nowMap = (Map) nowMap.get(word); //获取指定key
if(nowMap != null){ //存在，则判断是否为最后一个
matchFlag++; //找到相应key，匹配标识+1
if("1".equals(nowMap.get("isEnd"))){ //如果为最后一个匹配规则,结束循环，返回匹配标识数
flag = true; //结束标志位为true
if(SensitiveWordUtils.minMatchTYpe == matchType){ //最小规则，直接返回,最大规则还需继续查找
break;
}
}
}
else{ //不存在，直接返回
break;
}
}
if(matchFlag < 2 || !flag){ //长度必须大于等于1，为词
matchFlag = 0;
}
return matchFlag;
}
public static boolean isWordValidate(String str){
boolean flag = true;
Set<String> set = getSensitiveWord(str, maxMatchType);
if(set.size()>0){
log.info("origin words:\t"+str);
log.info(("语句中包含敏感词的个数为：" + set.size() + "。包含：" + set));
flag = false;
}
return flag;
}
public static String replaceWord(String str){
SensitiveWordUtils filter = new SensitiveWordUtils();
return filter.replaceSensitiveWord(str, maxMatchType, "*");
}
public static void main(String[] args) {
// SensitiveWordUtils filter = new SensitiveWordUtils();
// System.out.println("敏感词的数量：" + filter.sensitiveWordMap.size());
String string = "太多的伤感情怀也许只局限于饲养基地 荧幕中的情节，主人公尝试着去用某种方式渐渐的很潇洒地释自杀指南怀那些自己经历的伤感。";
// System.out.println("待检测语句字数：" + string.length());
long beginTime = System.currentTimeMillis();
// System.out.println(isWordValidate(string));
System.out.println("替换后的结果："+replaceWord(string));
long endTime = System.currentTimeMillis();
System.out.println("总共消耗时间为：" + (endTime - beginTime));
}
}
PageUtils
/**
* Copyright 2018 人人开源 http://www.renren.io
* <p>
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
* <p>
* http://www.apache/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.yymt.startalk_yyt.common;
import com.baomidou.mybatisplus.plugins.Page;
import java.io.Serializable;
import java.util.List;
/**
* 分页工具类
*
* @author chenshun
* @email sunlightcs@gmail
* @date 2016年11月4日 下午12:59:00
*/
public class PageUtils implements Serializable {
private static final long serialVersionUID = 1L;
//总记录数
private int totalCount;
//每页记录数
private int pageSize;
//总页数
private int totalPage;
//当前页数
private int currPage;
//列表数据
private List<?> list;
/**
* 分页
* @param list 列表数据
* @param totalCount 总记录数
* @param pageSize 每页记录数
* @param currPage 当前页数
*/
public PageUtils(List<?> list, int totalCount, int pageSize, int currPage) {
this.list = list;
this.totalCount = totalCount;
this.pageSize = pageSize;
this.currPage = currPage;
this.totalPage = (int)Math.ceil((double)totalCount/pageSize);
}
/**
* 分页
*/
public PageUtils(Page<?> page) {
this.list = page.getRecords();
this.totalCount = page.getTotal();
this.pageSize = page.getSize();
this.currPage = page.getCurrent();
this.totalPage = page.getPages();
}
public int getTotalCount() {
return totalCount;
}
public void setTotalCount(int totalCount) {
this.totalCount = totalCount;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getTotalPage() {
return totalPage;
}
public void setTotalPage(int totalPage) {
this.totalPage = totalPage;
}
public int getCurrPage() {
return currPage;
}
public void setCurrPage(int currPage) {
this.currPage = currPage;
}
public List<?> getList() {
return list;
}
public void setList(List<?> list) {
this.list = list;
}
}
完整pom.xml
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- Swagger -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- mybatis -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.3</version>
</dependency>
<!-- postgresql -->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- log -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.13</version>
</dependency>
<!-- 阿里大礼包 (里面包含了JSONObject) -->
<!-- <dependency>
<groupId>com.aliyun.oss</groupId>
<artifactId>aliyun-sdk-oss</artifactId>
<version>2.5.0</version>
</dependency>-->
<!-- JSONObject对象依赖的jar包 开始 -->
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.9.3</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.6</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>net.sf.ezmorph</groupId>
<artifactId>ezmorph</artifactId>
<version>1.0.6</version>
</dependency>
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.2.3</version>
<classifier>jdk15</classifier>
<!-- jdk版本 -->
</dependency>
<!-- Json依赖架包下载结束 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus</artifactId>
<version>2.1.6</version>
</dependency>
</dependencies>
浏览器访问: http://localhost:9090/swagger-ui.html#/
本文标签： SpringBootswagger
版权声明：本文标题：springboot整合swagger (实测可行版) 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：https://m.elefans.com/xitong/1727774277a1128924.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论