11

sws

2022-09-27 0841189aa3e92f0d3d0263ba1923a5c2e88a0b42

11

 pom.xml

@@ -6,7 +6,7 @@
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <version>2.3.0.RELEASE</version>
        <relativePath/>
    </parent>

@@ -131,17 +131,22 @@
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-text</artifactId>
            <version>1.1</version>
        </dependency>
        <!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>3.0.0</version>
            <version>2.9.2</version>
        </dependency>
        <!--swagger ui-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>3.0.0</version>
            <version>2.9.2</version>
        </dependency>
        <!--<dependency>
            <groupId>org.thymeleaf.extras</groupId>

 src/main/java/com/lf/server/config/ShiroConfig.java

@@ -24,7 +24,7 @@
 * @author
 */
@SuppressWarnings("ALL")
@Configuration
//@Configuration
public class ShiroConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean

 src/main/java/com/lf/server/config/SwaggerConfig.java

@@ -1,6 +1,13 @@
package com.lf.server.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
@@ -10,5 +17,19 @@
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    //
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.lf.server.controller"))
                .paths(PathSelectors.any()).build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Spring Boot接口API")
                .description("Spring Boot示例接口API")
                .version("1.0").build();
    }
}

 src/main/java/com/lf/server/config/WebMVCConfig.java

ÎļþÒÑɾ³ý

 src/main/java/com/lf/server/controller/BaseController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,38 @@
package com.lf.server.controller;

import com.lf.server.entity.all.HttpStatus;
import com.lf.server.entity.all.ResponseMsg;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * Controller基类
 * @author www
 */
public class BaseController {
    public Log log = LogFactory.getLog(getClass());

    public <T> ResponseMsg<T> success(T result) {
        return new ResponseMsg<T>(HttpStatus.OK, result);
    }

    public <T> ResponseMsg<T> success(String msg, T result) {
        return new ResponseMsg<T>(HttpStatus.OK, msg, result);
    }

    public <T> ResponseMsg<T> success(int count, T result) {
        return new ResponseMsg<T>(HttpStatus.OK, count, result);
    }

    public <T> ResponseMsg<T> success(String msg, int count, T result) {
        return new ResponseMsg<T>(HttpStatus.OK, msg, count, result);
    }

    public <T> ResponseMsg<T> fail(T result) {
        return new ResponseMsg<T>(HttpStatus.ERROR, result);
    }

    public <T> ResponseMsg<T> fail(String msg, T result) {
        return new ResponseMsg<T>(HttpStatus.ERROR, msg, result);
    }
}

 src/main/java/com/lf/server/controller/data/DepController.java

@@ -1,7 +1,14 @@
package com.lf.server.controller.data;

import com.lf.server.controller.BaseController;
import com.lf.server.entity.all.ResponseMsg;
import com.lf.server.entity.data.DepEntity;
import com.lf.server.entity.data.DictEntity;
import com.lf.server.service.data.DepService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@@ -13,53 +20,116 @@
 * @date   2022-09-23
 */

@Api(tags = "组织机构")
@RestController
@RequestMapping("/dep")
public class DepController {
public class DepController extends BaseController {
    @Autowired
    DepService depService;

    @RequestMapping(value ="/insertDep", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer insertDep(DepEntity depEntity){
    @ApiOperation(value = "插入数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "DepEntity", value = "字典实体类", dataType = "com.lf.server.entity.data.DepEntity", paramType = "body", example = "")
    })
    @RequestMapping(value = "/insertDep", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public ResponseMsg<Integer> insertDep(DepEntity depEntity) {
        try {
            int count = depService.insertDep(depEntity);

        return depService.insertDep(depEntity);
    }

    @RequestMapping(value ="/insertDes", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer insertDes(@RequestBody List<DepEntity> depEntity){

        return depService.insertDeps(depEntity);
    }
    @ResponseBody
    @RequestMapping(value ="/deleteDep", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer deleteDep(int id){
        return depService.deleteDep(id);
    }


    @RequestMapping(value ="/deleteDeps", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer deleteDeps(@RequestBody List<Integer> ids){
        if(!ids.isEmpty()){
            return depService.deleteDeps(ids);
        }else {
            return -1;
            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "插入多条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "DepEntity", value = "字典实体类", dataType = "com.lf.server.entity.data.DepEntity", paramType = "body", example = "")
    })
    @RequestMapping(value = "/insertDes", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public ResponseMsg<Integer> insertDes(@RequestBody List<DepEntity> depEntity) {
        try {
            int count = depService.insertDeps(depEntity);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "删除一条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "主键ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/deleteDep")
    public ResponseMsg<Integer> deleteDep(int id) {
        try {
            int count = depService.deleteDep(id);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "删除多条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "ids", value = "主键ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/deleteDeps")
    public ResponseMsg<Integer> deleteDeps(List<Integer> ids) {
        try {
            if (ids == null || ids.isEmpty()) {
                return fail("id数组不能为空", -1);
            }

            int count = depService.deleteDeps(ids);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "更新一条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "depEntity", value = "主键ID集合", dataType = "DepEntity", paramType = "body", example = "")
    })
    @ResponseBody
    @RequestMapping(value ="/updateDep", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer updateDep(DepEntity depEntity){
        return depService.updateDep(depEntity);
    @RequestMapping(value = "/updateDep", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public ResponseMsg<Integer> updateDep(DepEntity depEntity) {
        try {
            int count = depService.updateDep(depEntity);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @GetMapping(value ="/selectDep")
    public DepEntity selectDep(int id){
        return depService.selectDep(id);
    @ApiOperation(value = "根据ID查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "主键ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/selectDep")
    public ResponseMsg<DepEntity> selectDep(int id) {
        try {
            DepEntity de = depService.selectDep(id);
            return success(de);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }

    @GetMapping(value ="/selectDepAll")
    public List<DepEntity> selectDepAll( ){
        return depService.selectDepAll( );
    @ApiOperation(value = "查询所有数据")
    @GetMapping(value = "/selectDepAll")
    public ResponseMsg<List<DepEntity>> selectDepAll() {
        try {
            List<DepEntity> list = depService.selectDepAll();
            return success(list);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }

}

 src/main/java/com/lf/server/controller/data/DictController.java

@@ -1,6 +1,8 @@
package com.lf.server.controller.data;


import com.lf.server.controller.BaseController;
import com.lf.server.entity.all.ResponseMsg;
import com.lf.server.entity.data.DictEntity;
import com.lf.server.service.data.DictService;
import io.swagger.annotations.Api;
@@ -14,87 +16,194 @@

/**
 * å­—典管理
 * @author sws
 * @author SWS + WWW
 * @date 2022-09.26
 */
@Api(tags = "DictController", description = "字典管理")
@Api(tags = "字典管理")
@RestController
@RequestMapping("/Dict")
public class DictController {
@RequestMapping("/dict")
public class DictController extends BaseController {
    @Autowired
    DictService dictService;

    @ApiOperation(value = "查询记录数", notes = "查询记录数")
    @ApiOperation(value = "查询记录数")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "tab", value = "表名", dataType = "String", paramType = "query", required = false, example = "sys_dict")
    })
    @GetMapping({"/selectCount"})
    public Integer selectCount(String tab) {
        return dictService.selectCount(tab);
    public ResponseMsg<Integer> selectCount(String tab) {
        try {
            int count = dictService.selectCount(tab);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "分页查询", notes = "分页查询")
    @ApiOperation(value = "分页查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "tab", value = "表名", dataType = "String", paramType = "query", required = false, example = "sys_dict"),
            @ApiImplicitParam(name = "pageSize", value = "每页条数", dataType = "Integer", paramType = "query", required = false, example = "10"),
            @ApiImplicitParam(name = "pageIndex", value = "分页索引（从0开始）", dataType = "Integer", paramType = "query", required = false, example = "0")
            @ApiImplicitParam(name = "tab", value = "表名", dataType = "String", paramType = "query", example = "sys_dict"),
            @ApiImplicitParam(name = "pageSize", value = "每页条数", dataType = "Integer", paramType = "query", example = "10"),
            @ApiImplicitParam(name = "pageIndex", value = "分页索引（从0开始）", dataType = "Integer", paramType = "query", example = "0")
    })
    @GetMapping(value = "/selectByPage")
    public List<DictEntity> selectByPage(String tab, Integer pageSize, Integer pageIndex) {
        if (pageSize < 1 || pageIndex < 0) {
            return null;
        }
    public ResponseMsg<List<DictEntity>> selectByPage(String tab, Integer pageSize, Integer pageIndex) {
        try {
            if (pageSize < 1 || pageIndex < 0) {
                return fail("分页数小于1或分页索引小于0", null);
            }

        return dictService.selectByPage(tab, pageSize, pageSize * pageIndex);
    }
            List<DictEntity> rs = dictService.selectByPage(tab, pageSize, pageSize * pageIndex);

    @RequestMapping(value = "/insertDict", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer insertDict(DictEntity dictEntity) {

        return dictService.insertDict(dictEntity);
    }

    @RequestMapping(value = "/insertDicts", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer insertDicts(@RequestBody List<DictEntity> dictEntity) {

        return dictService.insertDicts(dictEntity);
    }

    @ResponseBody
    @RequestMapping(value = "/deleteDict", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer deleteStyle(int id) {
        return dictService.deleteDict(id);
    }


    @RequestMapping(value = "/deleteDicts", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer deleteDicts(@RequestBody List<Integer> ids) {
        if (!ids.isEmpty()) {
            return dictService.deleteDicts(ids);
        } else {
            return -1;
            return success(rs);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }

    @ResponseBody
    @RequestMapping(value = "/updateDict", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer updateDict(DictEntity dictEntity) {
        return dictService.updateDict(dictEntity);
    @ApiOperation(value = "分页查询并返回记录数")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "tab", value = "表名", dataType = "String", paramType = "query", example = "sys_dict"),
            @ApiImplicitParam(name = "pageSize", value = "每页条数", dataType = "Integer", paramType = "query", example = "10"),
            @ApiImplicitParam(name = "pageIndex", value = "分页索引（从0开始）", dataType = "Integer", paramType = "query", example = "0")
    })
    @GetMapping(value = "/selectByPageAndCount")
    public ResponseMsg<List<DictEntity>> selectByPageAndCount(String tab, Integer pageSize, Integer pageIndex) {
        try {
            if (pageSize < 1 || pageIndex < 0) {
                return fail("分页数小于1或分页索引小于0", null);
            }

            int count = dictService.selectCount(tab);
            if (count == 0) {
                return success(0, null);
            }

            List<DictEntity> rs = dictService.selectByPage(tab, pageSize, pageSize * pageIndex);

            return success(count, rs);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }

    @ApiOperation(value = "插入字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "dictEntity", value = "字典实体类", dataType = "com.lf.server.entity.data.DictEntity", paramType = "body", example = "")
    })
    @PostMapping(value = "/insertDict", produces = "application/json; charset=UTF-8")
    public ResponseMsg<Integer> insertDict(DictEntity dictEntity) {
        try {
            int count = dictService.insertDict(dictEntity);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "插入多条字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "dictEntity", value = "字典实体类集合", dataType = "List<DictEntity>", paramType = "body", example = "")
    })
    @PostMapping(value = "/insertDicts", produces = "application/json; charset=UTF-8")
    public ResponseMsg<Integer> insertDicts(@RequestBody List<DictEntity> dictEntity) {
        try {
            int count = dictService.insertDicts(dictEntity);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "删除一条字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "字典ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/deleteDict")
    public ResponseMsg<Integer> deleteDict(int id) {
        try {
            int count = dictService.deleteDict(id);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "删除多条字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "ids", value = "字典ID集合", dataType = "List<Integer>", paramType = "query", example = "1,2")
    })
    @GetMapping(value = "/deleteDicts")
    public ResponseMsg<Integer> deleteDicts(List<Integer> ids) {
        try {
            if (ids == null || ids.isEmpty()) {
                return fail("id数组不能为空", -1);
            }

            int count = dictService.deleteDicts(ids);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "更新一条字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "dictEntity", value = "字典ID集合", dataType = "DictEntity", paramType = "body", example = "")
    })
    @ResponseBody
    @PostMapping(value = "/updateDict", produces = "application/json; charset=UTF-8")
    public ResponseMsg<Integer> updateDict(DictEntity dictEntity) {
        try {
            int count = dictService.updateDict(dictEntity);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "根据ID查询字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "字典ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/selectDict")
    public DictEntity selectDict(int id) {
        return dictService.selectDict(id);
    public ResponseMsg<DictEntity> selectDict(int id) {
        try {
            DictEntity de = dictService.selectDict(id);

            return success(de);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }

    @ApiOperation(value = "查询所有字典")
    @GetMapping(value = "/selectDictAll")
    public List<DictEntity> selectDictAll() {
        return dictService.selectDictAll();
    public ResponseMsg<List<DictEntity>> selectDictAll() {
        try {
            List<DictEntity> list = dictService.selectDictAll();

            return success(list);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }


    @ApiOperation(value = "查询字典中的所有表名")
    @GetMapping(value = "/selectDictTab")
    public List<DictEntity> selectDictTab() {
        return dictService.selectDictTab();
    public ResponseMsg<List<DictEntity>> selectDictTab() {
        try {
            List<DictEntity> list = dictService.selectDictTab();

            return success(list);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }
}

 src/main/java/com/lf/server/controller/data/DirController.java

@@ -1,7 +1,13 @@
package com.lf.server.controller.data;

import com.lf.server.controller.BaseController;
import com.lf.server.entity.all.ResponseMsg;
import com.lf.server.entity.data.DirEntity;
import com.lf.server.service.data.DirService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@@ -12,59 +18,101 @@
 * @author sws
 * @date   2022-09-22
 */

@Api(tags = "目录管理")
@RestController
@RequestMapping("/dir")
public class DirController {
public class DirController extends BaseController {
    @Autowired
    DirService dirService;

    @ApiOperation(value = "插入数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "DirEntity", value = "目录实体类", dataType = "com.lf.server.entity.data.DirEntity", paramType = "body", example = "")
    })
    @RequestMapping(value = "/insertDir", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer insertDir(DirEntity dirEntity) {
    public ResponseMsg<Integer> insertDir(DirEntity dirEntity) {
        try {
            int count = dirService.insertDir(dirEntity);

        return dirService.insertDir(dirEntity);
            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "插入多条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "DirEntity", value = "目录实体类", dataType = "com.lf.server.entity.data.DirEntity", paramType = "body", example = "")
    })
    @RequestMapping(value = "/insertDirs", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer insertDirs(@RequestBody List<DirEntity> dirEntity) {
    public ResponseMsg<Integer> insertDirs(@RequestBody List<DirEntity> dirEntity) {
        try {
            int count = dirService.insertDirs(dirEntity);

        return dirService.insertDirs(dirEntity);
    }

    @ResponseBody
    @RequestMapping(value = "/deleteDir", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer deleteDir(int id) {

        return dirService.deleteDir(id);
    }


    @RequestMapping(value = "/deleteDirs", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer deleteDirs(@RequestBody List<Integer> ids) {

        if (!ids.isEmpty()) {

            return dirService.deleteDirs(ids);

        } else {

            return -1;
            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ResponseBody
    @RequestMapping(value = "/updateDir", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer updateDir(DirEntity dirEntity) {
    @ApiOperation(value = "删除一条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "主键ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/deleteDir")
    public  ResponseMsg<Integer> deleteDir(int id) {
        try {
            int count = dirService.deleteDir(id);

        return dirService.updateDir(dirEntity);
            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "删除多条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "ids", value = "主键ID集合", dataType = "List<Integer>", paramType = "query", example = "1,2")
    })
    @GetMapping(value = "/deleteDirs")
    public ResponseMsg<Integer> deleteDirs( List<Integer> ids) {
         try {
            if (ids == null || ids.isEmpty()) {
                return fail("id数组不能为空", -1);
            }

            int count = dirService.deleteDirs(ids);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }
    @ApiOperation(value = "更新一条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "dirEntity", value = "主键ID集合", dataType = "DictEntity", paramType = "body", example = "")
    })
    @ResponseBody
    @RequestMapping(value = "/updateDir", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public ResponseMsg<Integer> updateDir(DirEntity dirEntity) {
        try {
            int count =  dirService.updateDir(dirEntity);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "根据ID查询数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "主键ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @ResponseBody
    @RequestMapping(value = "/selectDir", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public DirEntity selectDir(int id) {
        return dirService.selectDir(id);
    }

    @ApiOperation(value = "查询所有数据")
    @GetMapping(value = "/selectDirAll")
    public List<DirEntity> selectDirAll() {


 src/main/java/com/lf/server/controller/data/MenusController.java

@@ -1,7 +1,14 @@
package com.lf.server.controller.data;

import com.lf.server.controller.BaseController;
import com.lf.server.entity.all.ResponseMsg;
import com.lf.server.entity.data.DictEntity;
import com.lf.server.entity.data.MenusEntity;
import com.lf.server.service.data.MenusService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@@ -13,54 +20,117 @@
 * @date   2022-09-23
 */

@Api(tags= "菜单管理")
@RestController
@RequestMapping("/Menu")
public class MenusController {
public class MenusController extends BaseController {
    @Autowired
    MenusService menuService;

    @ApiOperation(value = "插入一条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "MenusEntity", value = "字典实体类", dataType = "com.lf.server.entity.data.MenusEntity", paramType = "body", example = "")
    })
    @RequestMapping(value = "/insertMenu", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer insertMenu(MenusEntity menusEntity) {

        return menuService.insertMenu(menusEntity);
    }

    @RequestMapping(value = "/insertMenus", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer insertMenus(@RequestBody List<MenusEntity> menusEntity) {

        return menuService.insertMenus(menusEntity);
    }

    @ResponseBody
    @RequestMapping(value = "/deleteMenu", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer deleteMenu(int id) {
        return menuService.deleteMenu(id);
    }


    @RequestMapping(value = "/deleteMenus", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer deleteMenus(@RequestBody List<Integer> ids) {
        if (!ids.isEmpty()) {
            return menuService.deleteMenus(ids);
        } else {
            return -1;
    public ResponseMsg<Integer> insertMenu(MenusEntity menusEntity) {
        try {
            int count = menuService.insertMenu(menusEntity);
            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "插入多条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "MenusEntity", value = "字典实体类", dataType = "com.lf.server.entity.data.MenusEntity", paramType = "body", example = "")
    })
    @RequestMapping(value = "/insertMenus", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public ResponseMsg<Integer> insertMenus(@RequestBody List<MenusEntity> menusEntity) {
        try {
            int count = menuService.insertMenus(menusEntity);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "删除一条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "主键ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/deleteMenu")
    public ResponseMsg<Integer> deleteMenu(int id) {
        try {
            int count = menuService.deleteMenu(id);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "删除多条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "主键ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/deleteMenus")
    public ResponseMsg<Integer> deleteMenus( List<Integer> ids) {
        try {
            if (ids == null || ids.isEmpty()) {
                return fail("id数组不能为空", -1);
            }

            int count = menuService.deleteMenus(ids);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "更新一条数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "MenusEntity", value = "菜单ID集合", dataType = "MenusEntity", paramType = "body", example = "")
    })
    @ResponseBody
    @RequestMapping(value = "/updateMenu", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer updateMenu(MenusEntity menusEntity) {
        return menuService.updateMenu(menusEntity);
    public ResponseMsg<Integer> updateMenu(MenusEntity menusEntity) {
        try {
            int count = menuService.updateMenu(menusEntity);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "根据ID查询字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "字典ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/selectMenu")
    public MenusEntity selectMenu(int id) {
        return menuService.selectMenu(id);
    public ResponseMsg<MenusEntity> selectMenu(int id) {
        try {
            MenusEntity menusEntity = menuService.selectMenu(id);

            return success(menusEntity);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }

    @ApiOperation(value = "查询所有字典")
    @GetMapping(value = "/selectMenuAll")
    public List<MenusEntity> selectMenuAll() {
        return menuService.selectMenuAll();
    public ResponseMsg<List<MenusEntity>> selectMenuAll() {
        try {
            List<MenusEntity> list = menuService.selectMenuAll();

            return success(list);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }

}

 src/main/java/com/lf/server/controller/data/StyleController.java

@@ -1,8 +1,14 @@
package com.lf.server.controller.data;

import com.lf.server.controller.BaseController;
import com.lf.server.entity.all.ResponseMsg;
import com.lf.server.entity.data.DictEntity;
import com.lf.server.entity.data.StyleEntity;
import com.lf.server.service.data.StyleService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@@ -13,68 +19,182 @@
 * @author sws
 * @date 2022-09.26
 */

@Api(tags = "样式管理")
@RestController
@RequestMapping("/Style")
public class StyleController {
public class StyleController extends BaseController {
    @Autowired
    StyleService styleService;

    @ApiOperation(value = "查询记录数")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "name", value = "名称", dataType = "String", paramType = "query", required = false, example = "sys_style")
    })
    @GetMapping({"/selectCount"})
    public Integer selectCount(String name) {
        return styleService.selectCount(name);
    public ResponseMsg<Integer> selectCount(String name) {
        try {
            int count = styleService.selectCount(name);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "分页查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "name", value = "名称", dataType = "String", paramType = "query", required = false, example = "sys_style"),
            @ApiImplicitParam(name = "pageSize", value = "每页条数", dataType = "Integer", paramType = "query", example = "10"),
            @ApiImplicitParam(name = "pageIndex", value = "分页索引（从0开始）", dataType = "Integer", paramType = "query", example = "0")
    })
    @GetMapping(value = "/selectByPage")
    public List<StyleEntity> selectByPage(String name, Integer pageSize, Integer pageIndex) {
        if (pageSize < 1 || pageIndex < 0) {
            return null;
    public ResponseMsg<List<StyleEntity>> selectByPage(String name, Integer pageSize, Integer pageIndex) {
        try {
            if (pageSize < 1 || pageIndex < 0) {
                return fail("分页数小于1或分页索引小于0", null);
            }

            List<StyleEntity> rs = styleService.selectByPage(name, pageSize, pageSize * pageIndex);

            return success(rs);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }

        return styleService.selectByPage(name, pageSize, pageSize * pageIndex);
    }

    @ApiOperation(value = "分页查询并返回记录数")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "name", value = "名称", dataType = "String", paramType = "query", example = "sys_style"),
            @ApiImplicitParam(name = "pageSize", value = "每页条数", dataType = "Integer", paramType = "query", example = "10"),
            @ApiImplicitParam(name = "pageIndex", value = "分页索引（从0开始）", dataType = "Integer", paramType = "query", example = "0")
    })

    @GetMapping(value = "/selectByPageAndCount")
    public ResponseMsg<List<StyleEntity>> selectByPageAndCount(String name, Integer pageSize, Integer pageIndex) {
        try {
            if (pageSize < 1 || pageIndex < 0) {
                return fail("分页数小于1或分页索引小于0", null);
            }

            int count = styleService.selectCount(name);
            if (count == 0) {
                return success(0, null);
            }

            List<StyleEntity> rs = styleService.selectByPage(name, pageSize, pageSize * pageIndex);

            return success(count, rs);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }

    @ApiOperation(value = "插入字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "StyleEntity", value = "字典实体类", dataType = "List<StyleEntity>", paramType = "body", example = "")
    })
    @RequestMapping(value = "/insertStyle", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer insertStyle(StyleEntity styleEntity) {
    public ResponseMsg<Integer> insertStyle(StyleEntity styleEntity) {
        try {
            int count = styleService.insertStyle(styleEntity);

        return styleService.insertStyle(styleEntity);
    }

    @RequestMapping(value = "/insertStyles", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer insertStyles(@RequestBody List<StyleEntity> styleEntity) {

        return styleService.insertStyles(styleEntity);
    }

    @ResponseBody
    @RequestMapping(value = "/deleteStyle", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer deleteStyle(int id) {
        return styleService.deleteStyle(id);
    }


    @RequestMapping(value = "/deleteStyles", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer deleteStyles(@RequestBody List<Integer> ids) {
        if (!ids.isEmpty()) {
            return styleService.deleteStyles(ids);
        } else {
            return -1;
            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "插入多条字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "StyleEntity", value = "字典实体类", dataType = "com.lf.server.entity.data.StyleEntity", paramType = "body", example = "")
    })
    @RequestMapping(value = "/insertStyles", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public ResponseMsg<Integer> insertStyles(@RequestBody List<StyleEntity> styleEntity) {
        try {
            int count = styleService.insertStyles(styleEntity);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "删除一条字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "字典ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/deleteStyle")
    public ResponseMsg<Integer> deleteStyle(int id) {
        try {
            int count = styleService.deleteStyle(id);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "删除多条字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "字典ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/deleteStyles")
    public ResponseMsg<Integer> deleteStyles( List<Integer> ids) {
        try {
            if (ids == null || ids.isEmpty()) {
                return fail("id数组不能为空", -1);
            }

            int count = styleService.deleteStyles(ids);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "更新一条字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "styleEntity", value = "字典ID集合", dataType = "StyleEntity", paramType = "body", example = "")
    })
    @ResponseBody
    @RequestMapping(value = "/updateStyle", method = RequestMethod.POST, produces = "application/json; charset=UTF-8")
    public Integer updateStyle(StyleEntity styleEntity) {
        return styleService.updateStyle(styleEntity);
    public ResponseMsg<Integer> updateStyle(StyleEntity styleEntity) {
        try {
            int count = styleService.updateStyle(styleEntity);

            return success(count);
        } catch (Exception ex) {
            return fail(ex.getMessage(), -1);
        }
    }

    @ApiOperation(value = "根据ID查询字典")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "字典ID", dataType = "Integer", paramType = "query", example = "1")
    })
    @GetMapping(value = "/selectStyle")
    public StyleEntity selectStyle(int id) {
        return styleService.selectStyle(id);
    public ResponseMsg<StyleEntity> selectStyle(int id) {
        try {
            StyleEntity styleEntity = styleService.selectStyle(id);
            ;

            return success(styleEntity);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }

    @ApiOperation(value = "查询所有字典")
    @GetMapping(value = "/selectStyleAll")
    public List<StyleEntity> selectStyleAll() {
        return styleService.selectStyleAll();
    public ResponseMsg<List<StyleEntity>> selectStyleAll() {

        try {
            List<StyleEntity> list = styleService.selectStyleAll();
            return success(list);
        } catch (Exception ex) {
            return fail(ex.getMessage(), null);
        }
    }
}

 src/main/java/com/lf/server/entity/all/HttpStatus.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,86 @@
package com.lf.server.entity.all;

/**
 * HttpStatus
 * @author
 */
public enum HttpStatus {
    OK(200,"请求成功"),

    BAD_REQUEST(400,"请求无效"),

    UNAUTHORIZED(401,"未经授权访问"),

    NOT_FOUND(404,"服务请求未找到"),

    NODATA_FOUND(404404,"数据未找到"),

    ERROR(500,"系统错误"),

    UNIQUE_ERROR(500100,"数据唯一性错误,存在重复的数据"),

    VALIDATE_ERROR(500101,"参数校验错误"),

    TOKEN_ERROR(500102,"token错误"),

    NO_LOGIN_ERROR(500104,"用户未登陆"),

    LOGIN_ERROR(500105,"用户登陆失败"),

    NO_AUTH_ERROR(500106,"无权限访问"),

    LOGIN_USER_ERROR(500107,"用户名错误"),

    LOGIN_PWD_ERROR(500108,"用户密码错误"),

    USER_LOCK_ERROR(500109,"用户被锁定"),

    PWD_NONSTANDARD(500111,"用户密码不合规范"),

    ACCOUNT_TYPE_ERROR(500112,"用户账号类型不匹配"),

    EMAIL_NONSTANDARD(500113,"邮箱格式错误！"),

    PHONE_NONSTANDARD(500114,"电话格式错误！"),

    DATA_NO_AUTH_ERROR(500115,"数据不在查询范围内"),

    LOGIN_PWD_EXPIRE(500116,"密码过期"),

    WORK_FLOW_SUBMIT_ERROR(500200,"流程提交错误"),

    WORK_FLOW_APPROVAL_ERROR(500201,"流程审核错误"),

    WORK_FLOW_REJECT_ERROR(500202,"流程退回错误"),

    WORK_FLOW_CANCEL_ERROR(500203,"流程取消错误"),

    WORK_FLOW_NO_EXIST(500204,"不存在流程历史记录"),

    EMAIL_CONFIG_ERROR(500300,"邮箱未配置"),

    JST_CONFIG_ERROR(500301,"即时通未配置"),

    JST_ACCOUNT_ERROR(500302,"即时账号错误"),

    SECRET_KEY_ERROR(500304,"密钥未配置错误"),

    DB_DEL_NODATA_ERROR(500401,"删除0条数据");

    private HttpStatus(int value, String msg) {
        this.value = value;
        this.msg = msg;
    }

    private int value;

    private String msg;

    public int getValue() {
        return value;
    }

    public String getMsg() {
        return msg;
    }
}

 src/main/java/com/lf/server/entity/all/ResponseMsg.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,107 @@
package com.lf.server.entity.all;

/**
 * å“åº”消息
 * @author www
 * @param <T>
 */
public class ResponseMsg<T> {
    public ResponseMsg() {
        this.time = System.currentTimeMillis();
    }

    public ResponseMsg(HttpStatus code, T result) {
        this.code = code.getValue();
        this.msg = this.code == 200 ? "成功" : "失败";
        this.result = result;
        this.time = System.currentTimeMillis();
    }

    public ResponseMsg(HttpStatus code, String msg, T result) {
        this.code = code.getValue();
        this.msg = msg;
        this.result = result;
        this.time = System.currentTimeMillis();
    }

    public ResponseMsg(int code, String msg, T result, long time) {
        this.code = code;
        this.msg = msg;
        this.result = result;
        this.time = time;
    }

    public ResponseMsg(HttpStatus code, int count, T result) {
        this.code = code.getValue();
        this.msg = this.code == 200 ? "成功" : "失败";
        this.count = count;
        this.result = result;
        this.time = System.currentTimeMillis();
    }

    public ResponseMsg(HttpStatus code, String msg, int count, T result) {
        this.code = code.getValue();
        this.msg = msg;
        this.count = count;
        this.result = result;
        this.time = System.currentTimeMillis();
    }

    public ResponseMsg(int code, String msg, int count, T result, long time) {
        this.code = code;
        this.msg = msg;
        this.count = count;
        this.result = result;
        this.time = time;
    }

    private int code;

    private String msg;

    private int count;

    private T result;

    private long time;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public T getResult() {
        return result;
    }

    public void setResult(T result) {
        this.result = result;
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }
}

 src/main/resources/application.yml

@@ -7,9 +7,6 @@
  context-path: /land

spring:
  mvc:
    pathmatch:
      matching-strategy: ant_path_matcher
  datasource:
    username : postgres
    password: postgres