Java毕业设计实战项目之仓库管理系统的实现流程

Java毕业设计实战项目之仓库管理系统的实现流程

基于SSM框架的仓库管理系统

功能:

系统操作权限管理。系统提供基本的登入登出功能，同时系统包含两个角色：系统超级管理员和普通管理员，超级管理员具有最高的操作权限，而普通管理员仅具有最基本的操作权限，而且仅能操作自己被指派的仓库。

请求URL鉴权。对于系统使用者登陆后进行操作发送请求的URL，后台会根据当前用户的角色判断是否拥有请求该URL的权限。

基础数据信息管理。对包括：货物信息、供应商信息、客户信息、仓库信息在内的基础数据信息进行管理，提供的操作有：添加、删除、修改、条件查询、导出为Excel和到从Excel导入。

仓库管理员管理。对仓库管理员信息CRUD操作，或者为指定的仓库管理员指派所管理的仓库。上述中的仓库管理员可以以普通管理员身份登陆到系统。

库存信息管理。对库存信息的CRUD操作，导入导出操作，同时查询的时候可以根据仓库以及商品ID等信息进行多条件查询。

基本仓库事务操作。执行货物的入库与出库操作。

系统登陆日志查询。超级管理员可以查询某一用户在特定时间段内的系统登陆日志。

系统操作日志查询。超级管理员可以查询某一用户在特定时间段内对系统进行操作的操作记录。

密码修改。

使用到的框架和库:

Apache POI

MyBatis

Spring Framework

Spring MVC

Apache Shiro

Ehcache

Apache Commons

Log4j

Slf4j

Jackson

C3P0

Junit

mysql-Connector

jquery

Bootstrap

仓库管理员管理请求:

/**

* 仓库管理员管理请求 Handler

*

* @author yy

*/

@Controller

@RequestMapping(value = "/**/repositoryAdminManage")

public class RepositoryAdminManageHandler {

@Autowired

private RepositoryAdminManageService repositoryAdminManageService;

// 查询类型

private static final String SEARCH_BY_ID = "searchByID";

private static final String SEARCH_BY_NAME = "searchByName";

private static final String SEARCH_BY_REPOSITORY_ID = "searchByRepositoryID";

private static final String SEARCH_ALL = "searchAll";

/**

* 通用记录查询

*

* @param keyWord 查询关键字

* @param searchType 查询类型

* @param offset 分页偏移值

* @param limit 分页大小

* @return 返回所有符合条件的记录

*/

private Map query(String keyWord, String searchType, int offset, int limit) throws RepositoryAdminManageServiceException {

Map queryResult = null;

// query

switch (searchType) {

case SEARCH_ALL:

queryResult = repositoryAdminManageService.selectAll(offset, limit);

break;

case SEARCH_BY_ID:

if (StringUtils.isNumeric(keyWord))

queryResult = repositoryAdminManageService.selectByID(Integer.valueOf(keyWord));

break;

case SEARCH_BY_NAME:

queryResult = repositoryAdminManageService.selectByName(offset, limit, keyWord);

break;

case SEARCH_BY_REPOSITORY_ID:

if (StringUtils.isNumeric(keyWord))

queryResult = repositoryAdminManageService.selectByRepositoryID(Integer.valueOf(keyWord));

break;

default:

// do other things

break;

}

return queryResult;

}

/**

* 查询仓库管理员信息

*

* @param searchType 查询类型

* @param offset 分页偏移值

* @param limit 分页大小

* @param keyWord 查询关键字

* @return 返回一个Map，其中key=rows，表示查询出来的记录；key=total，表示记录的总条数

*/

@SuppressWarnings("unchecked")

@RequestMapping(value = "getRepositoryAdminList", method = RequestMethod.GET)

public

@ResponseBody

Map getRepositoryAdmin(@RequestParam("searchType") String searchType,

@RequestParam("keyWord") String keyWord, @RequestParam("offset") int offset,

@RequestParam("limit") int limit) throws RepositoryAdminManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

List rows = null;

long total = 0;

// 查询

Map queryResult = query(keyWord, searchType, offset, limit);

if (queryResult != null) {

rows = (List) queryResult.get("data");

total = (long) queryResult.get("total");

}

// 设置 Response

responseContent.setCustomerInfo("rows", rows);

responseContent.setResponseTotal(total);

return responseContent.generateResponse();

}

/**

* 添加一条仓库管理员信息

*

* @param repositoryAdmin 仓库管理员信息

* @return 返回一个map，其中：key 为 result表示操作的结果，包括：success 与 error

*/

@RequestMapping(value = "addRepositoryAdmin", method = RequestMethod.POST)

public

@ResponseBody

Map addRepositoryAdmin(@RequestBody RepositoryAdmin repositoryAdmin) throws RepositoryAdminManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

// 添加结果

String result = repositoryAdminManageService.addRepositoryAdmin(repositoryAdmin)

? Response.RESPONSE_RESULT_SUCCESS : Response.RESPONSE_RESULT_ERROR;

// 设置 Response

responseContent.setResponseResult(result);

return responseContent.generateResponse();

}

/**

* 查询指定 ID 的仓库管理员信息

*

* @param repositoryAdminID 仓库管理员ID

* @return 返回一个map，其中：key 为 result 的值为操作的结果，包括：success 与 error；key 为 data

* 的值为仓库管理员信息

*/

@RequestMapping(value = "getRepositoryAdminInfo", method = RequestMethod.GET)

public

@ResponseBody

Map getRepositoryAdminInfo(Integer repositoryAdminID) throws RepositoryAdminManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

String result = Response.RESPONSE_RESULT_ERROR;

// 查询

RepositoryAdmin repositoryAdmin = null;

Map queryResult = repositoryAdminManageService.selectByID(repositoryAdminID);

if (queryResult != null) {

if ((repositoryAdmin = (RepositoryAdmin) queryResult.get("data")) != null)

result = Response.RESPONSE_RESULT_SUCCESS;

}

// 设置 Response

responseContent.setResponseResult(result);

responseContent.setResponseData(repositoryAdmin);

return responseContent.generateResponse();

}

/**

* 更新仓库管理员信息

*

* @param repositoryAdmin 仓库管理员信息

* @return 返回一个map，其中：key 为 result 的值为操作的结果，包括：success 与 error；key 为 data

* 的值为仓库管理员信息

*/

@RequestMapping(value = "updateRepositoryAdmin", method = RequestMethod.POST)

public

@ResponseBody

Map updateRepositoryAdmin(@RequestBody RepositoryAdmin repositoryAdmin) throws RepositoryAdminManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

// 更新

String result = repositoryAdminManageService.updateRepositoryAdmin(repositoryAdmin)

? Response.RESPONSE_RESULT_SUCCESS : Response.RESPONSE_RESULT_ERROR;

// 设置 Response

responseContent.setResponseResult(result);

return responseContent.generateResponse();

}

/**

* 删除指定 ID 的仓库管理员信息

*

* @param repositoryAdminID 仓库ID

* @return 返回一个map，其中：key 为 result 的值为操作的结果，包括：success 与 error；key 为 data

* 的值为仓库管理员信息

*/

@RequestMapping(value = "deleteRepositoryAdmin", method = RequestMethod.GET)

public

@ResponseBody

Map deleteRepositoryAdmin(Integer repositoryAdminID) throws RepositoryAdminManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

// 删除记录

String result = repositoryAdminManageService.deleteRepositoryAdmin(repositoryAdminID)

? Response.RESPONSE_RESULT_SUCCESS : Response.RESPONSE_RESULT_ERROR;

// 设置 Response

responseContent.setResponseResult(result);

return responseContent.generateResponse();

}

/**

* 从文件中导入仓库管理员信息

*

* @param file 保存有仓库管理员信息的文件

* @return 返回一个map，其中：key 为 result表示操作的结果，包括：success 与

* error；key为total表示导入的总条数；key为available表示有效的条数

*/

@RequestMapping(value = "importRepositoryAdmin", method = RequestMethod.POST)

public

@ResponseBody

Map importRepositoryAdmin(MultipartFile file) throws RepositoryAdminManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

String result = Response.RESPONSE_RESULT_ERROR;

// 读取文件

long total = 0;

long available = 0;

if (file != null) {

Map importInfo = repositoryAdminManageService.importRepositoryAdmin(file);

if (importInfo != null) {

total = (long) importInfo.get("total");

available = (long) importInfo.get("available");

result = Response.RESPONSE_RESULT_SUCCESS;

}

}

// 设置 Response

responseContent.setResponseResult(result);

responseContent.setResponseTotal(total);

responseContent.setCustomerInfo("available", available);

return responseContent.generateResponse();

}

/**

* 导出仓库管理员信息到文件中

*

* @param searchType 查询类型

* @param keyWord 查询关键字

* @param response HttpServletResponse

*/

@SuppressWarnings("unchecked")

@RequestMapping(value = "exportRepositoryAdmin", method = RequestMethod.GET)

public void exportRepositoryAdmin(@RequestParam("searchType") String searchType,

@RequestParam("keyWord") String keyWord, HttpServletResponse response) throws RepositoryAdminManageServiceException, IOException {

// 导出文件名

String fileName = "repositoryAdminInfo.xlsx";

// 查询

List repositoryAdmins;

Map queryResult = query(keyWord, searchType, -1, -1);

if (queryResult != null)

repositoryAdmins = (List) queryResult.get("data");

else

repositoryAdmins = new ArrayList<>();

// 生成文件

File file = repositoryAdminManageService.exportRepositoryAdmin(repositoryAdmins);

// 输出文件

if (file != null) {

// 设置响应头

response.addHeader("Content-Disposition", "attachment;filename=" + fileName);

FileInputStream inputStream = new FileInputStream(file);

OutputStream outputStream = response.getOutputStream();

byte[] buffer = new byte[8192];

int len;

while ((len = inputStream.read(buffer, 0, buffer.length)) > 0) {

outputStream.write(buffer, 0, len);

outputStream.flush();

}

inputStream.close();

outputStream.close();

}

}

}

货物信息管理请求:

/**

* 货物信息管理请求 Handler

*

* @author yy

*/

@RequestMapping(value = "/**/goodsManage")

@Controller

public class GoodsManageHandler {

@Autowired

private GoodsManageService goodsManageService;

private static final String SEARCH_BY_ID = "searchByID";

private static final String SEARCH_BY_NAME = "searchByName";

private static final String SEARCH_ALL = "searchAll";

/**

* 通用的记录查询

*

* @param searchType 查询类型

* @param keyWord 查询关键字

* @param offset 分页偏移值

* @param limit 分页大小

* @return 返回一个 Map ，包含所有符合要求的查询结果，以及记录的条数

*/

private Map query(String searchType, String keyWord, int offset, int limit) throws GoodsManageServiceException {

Map queryResult = null;

switch (searchType) {

case SEARCH_BY_ID:

if (StringUtils.isNumeric(keyWord))

queryResult = goodsManageService.selectById(Integer.valueOf(keyWord));

break;

case SEARCH_BY_NAME:

queryResult = goodsManageService.selectByName(keyWord);

break;

case SEARCH_ALL:

queryResult = goodsManageService.selectAll(offset, limit);

break;

default:

// do other thing

break;

}

return queryResult;

}

/**

* 搜索货物信息

*

* @param searchType 搜索类型

* @param offset 如有多条记录时分页的偏移值

* @param limit 如有多条记录时分页的大小

* @param keyWord 搜索的关键字

* @return 返回所有符合要求的记录

*/

@SuppressWarnings("unchecked")

@RequestMapping(value = "getGoodsList", method = RequestMethod.GET)

public

@ResponseBody

Map getGoodsList(@RequestParam("searchType") String searchType,

@RequestParam("offset") int offset, @RequestParam("limit") int limit,

@RequestParam("keyWord") String keyWord) throws GoodsManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

List rows = null;

long total = 0;

// 查询

Map queryResult = query(searchType, keyWord, offset, limit);

if (queryResult != null) {

rows = (List) queryResult.get("data");

total = (long) queryResult.get("total");

}

// 设置 Response

responseContent.setCustomerInfo("rows", rows);

responseContent.setResponseTotal(total);

return responseContent.generateResponse();

}

/**

* 添加一条货物信息

*

* @param goods 货物信息

* @return 返回一个map，其中：key 为 result表示操作的结果，包括：success 与 error

*/

@RequestMapping(value = "addGoods", method = RequestMethod.POST)

public

@ResponseBody

Map addGoods(@RequestBody Goods goods) throws GoodsManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

// 添加记录

String result = goodsManageService.addGoods(goods) ? Response.RESPONSE_RESULT_SUCCESS : Response.RESPONSE_RESULT_ERROR;

// 设置 Response

responseContent.setResponseResult(result);

return responseContent.generateResponse();

}

/**

* 查询指定 goods ID 货物的信息

*

* @param goodsID 货物ID

* @return 返回一个map，其中：key 为 result 的值为操作的结果，包括：success 与 error；key 为 data

* 的值为货物信息

*/

@RequestMapping(value = "getGoodsInfo", method = RequestMethod.GET)

public

@ResponseBody

Map getGoodsInfo(@RequestParam("goodsID") Integer goodsID) throws GoodsManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

String result = Response.RESPONSE_RESULT_ERROR;

// 获取货物信息

Goods goods = null;

Map queryResult = goodsManageService.selectById(goodsID);

if (queryResult != null) {

goods = (Goods) queryResult.get("data");

if (goods != null) {

result = Response.RESPONSE_RESULT_SUCCESS;

}

}

// 设置 Response

responseContent.setResponseResult(result);

responseContent.setResponseData(goods);

return responseContent.generateResponse();

}

/**

* 更新货物信息

*

* @param goods 货物信息

* @return 返回一个map，其中：key 为 result表示操作的结果，包括：success 与 error

*/

@RequestMapping(value = "updateGoods", method = RequestMethod.POST)

public

@ResponseBody

Map updateGoods(@RequestBody Goods goods) throws GoodsManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

// 更新

String result = goodsManageService.updateGoods(goods) ? Response.RESPONSE_RESULT_SUCCESS : Response.RESPONSE_RESULT_ERROR;

// 设置 Response

responseContent.setResponseResult(result);

return responseContent.generateResponse();

}

/**

* 删除货物记录

*

* @param goodsID 货物ID

* @return 返回一个map，其中：key 为 result表示操作的结果，包括：success 与 error

*/

@RequestMapping(value = "deleteGoods", method = RequestMethod.GET)

public

@ResponseBody

Map deleteGoods(@RequestParam("goodsID") Integer goodsID) throws GoodsManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

// 删除

String result = goodsManageService.deleteGoods(goodsID) ? Response.RESPONSE_RESULT_SUCCESS : Response.RESPONSE_RESULT_ERROR;

// 设置http:// Response

responseContent.setResponseResult(result);

return responseContent.generateResponse();

}

/**

* 导入货物信息

*

* @param file 保存有货物信息的文件

* @return 返回一个map，其中：key 为 result表示操作的结果，包括：success 与

* error；key为total表示导入的总条数；key为available表示有效的条数

*/

@RequestMapping(value = "importGoods", method = RequestMethod.POST)

public

@ResponseBody

Map importGoods(@RequestParam("file") MultipartFile file) throws GoodsManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

String result = Response.RESPONSE_RESULT_ERROR;

// 读取文件内容

int total = 0;

int available = 0;

if (file != null) {

Map importInfo = goodsManageService.importGoods(file);

if (importInfo != null) {

total = (int) importInfo.get("total");

available = (int) importInfo.get("available");

result = Response.RESPONSE_RESULT_SUCCESS;

}

}

// 设置 Response

responseContent.setResponseResult(result);

responseContent.setResponseTotal(total);

responseContent.setCustomerInfo("available", available);

return responseContent.generateResponse();

}

/**

* 导出货物信息

*

* @param searchType 查找类型

* @param keyWord 查找关键字

* @param response HttpServletResponse

*/

@SuppressWarnings("unchecked")

@RequestMapping(value = "exportGoods", method = RequestMethod.GET)

public void exportGoods(@RequestParam("searchType") String searchType, @RequestParam("keyWord") String keyWord,

HttpServletResponse response) throws GoodsManageServiceException, IOException {

String fileName = "goodsInfo.xlsx";

List goodsList = null;

Map queryResult = query(searchType, keyWord, -1, -1);

if (queryResult != null) {

goodsList = (List) queryResult.get("data");

}

// 获取生成的文件

File file = goodsManageService.exportGoods(goodsList);

// 写出文件

if (file != null) {

// 设置响应头

response.addHeader("Content-Disposition", "attachment;filename=" + fileName);

FileInputStream inputStream = new FileInputStream(file);

OutputStream outputStream = response.getOutputStream();

byte[] buffer = new byte[8192];

int len;

while ((len = inputStream.read(buffer, 0, buffer.length)) > 0) {

outputStream.write(buffer, 0, len);

outputStream.flush();

}

inputStream.close();

outputStream.close();

}

}

}

客户信息管理请求:

/**

* 客户信息管理请求

*

* @author yy

*/

@RequestMapping(value = "/**/customerManage")

@Controller

public class CustomerManageHandler {

@Autowired

private CustomerManageService customerManageService;

private static final String SEARCH_BY_ID = "searchByID";

private static final String SEARCH_BY_NAME = "searchByName";

private static final String SEARCH_ALL = "searchAll";

/**

* 通用的结果查询方法

*

* @param searchType 查询方式

* @param keyWord 查询关键字

* @param offset 分页偏移值

* @param limit 分页大小

* @return 返回指定条件查询的结果

*/

private Map query(String searchType, String keyWord, int offset, int limit) throws CustomerManageServiceException {

Map queryResult = null;

switch (searchType) {

case SEARCH_BY_ID:

if (StringUtils.isNumeric(keyWord))

queryResult = customerManageService.selectById(Integer.valueOf(keyWord));

break;

case SEARCH_BY_NAME:

queryResult = customerManageService.selectByName(offset, limit, keyWord);

break;

case SEARCH_ALL:

queryResult = customerManageService.selectAll(offset, limit);

break;

default:

// do other thing

break;

}

return queryResult;

}

/**

* 搜索客户信息

*

* @param searchType 搜索类型

* @param offset 如有多条记录时分页的偏移值

* @param limit 如有多条记录时分页的大小

* @param keyWord 搜索的关键字

* @return 返回查询的结果，其中键值为 rows 的代表查询到的每一记录，若有分页则为分页大小的记录；键值为 total 代表查询到的符合要求的记录总条数

*/

@SuppressWarnings("unchecked")

@RequestMapping(value = "getCustomerList", method = RequestMethod.GET)

public

@ResponseBody

Map getCustomerList(@RequestParam("searchType") String searchType,

@RequestParam("offset") int offset,

@RequestParam("limit") int limit,

@RequestParam("keyWord") String keyWord) throws CustomerManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

List rows = null;

long total = 0;

Map queryResult = query(searchType, kepICCgRyWord, offset, limit);

if (queryResult != null) {

rows = (List) queryResult.get("data");

total = (long) queryResult.get("total");

}

// 设置 Response

responseContent.setCustomerInfo("rows", rows);

responseContent.setResponseTotal(total);

responseContent.setResponseResult(Response.RESPONSE_RESULT_SUCCESS);

return responseContent.generateResponse();

}

/**

* 添加一条客户信息

*

* @param customer 客户信息

* @return 返回一个map，其中：key 为 result表示操作的结果，包括：success 与 error

*/

@RequestMapping(value = "addCustomer", method = RequestMethod.POST)

public

@ResponseBody

Map addCustomer(@RequestBody Customer customer) throws CustomerManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

// 添加记录

String result = customerManageService.addCustomer(customer) ? Response.RESPONSE_RESULT_SUCCESS : Response.RESPONSE_RESULT_ERROR;

responseContent.setResponseResult(result);

return responseContent.generateResponse();

}

/**

* 查询指定 customer ID 客户的信息

*

* @param customerID 客户ID

* @return 返回一个map，其中：key 为 result 的值为操作的结果，包括：success 与 error；key 为 data

* 的值为客户信息

*/

@RequestMapping(value = "getCustomerInfo", method = RequestMethod.GET)

public

@ResponseBody

Map getCustomerInfo(@RequestParam("customerID") String customerID) throws CustomerManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

String result = Response.RESPONSE_RESULT_ERROR;

// 获取客户信息

Customer customer = null;

Map queryResult = query(SEARCH_BY_ID, customerID, -1, -1);

if (queryResult != null) {

customer = (Customer) queryResult.get("data");

if (customer != null) {

result = Response.RESPONSE_RESULT_SUCCESS;

}

}

// 设置 Response

responseContent.setResponseResult(result);

responseContent.setResponseData(customer);

return responseContent.generateResponse();

}

/**

* 更新客户信息

*

* @param customer 客户信息

* @return 返回一个map，其中：key 为 result表示操作的结果，包括：success 与 error

*/

@RequestMapping(value = "updateCustomer", method = RequestMethod.POST)

public

@ResponseBody

Map updateCustomer(@RequestBody Customer customer) throws CustomerManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

// 更新

String result = customerManageService.updateCustomer(customer) ? Response.RESPONSE_RESULT_SUCCESS : Response.RESPONSE_RESULT_ERROR;

responseContent.setResponseResult(result);

return responseContent.generateResponse();

}

/**

* 删除客户记录

*

* @param customerIDStr 客户ID

* @return 返回一个map，其中：key 为 result表示操作的结果，包括：success 与 error

*/

@RequestMapping(value = "deleteCustomer", method = RequestMethod.GET)

public

@ResponseBody

Map deleteCustomer(@RequestParam("customerID") String customerIDStr) throws CustomerManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

// 参数检查

if (StringUtils.isNumeric(customerIDStr)) {

// 转换为 Integer

Integer customerID = Integer.valueOf(customerIDStr);

// 刪除

String result = customerManageService.deleteCustomer(customerID) ? Response.RESPONSE_RESULT_SUCCESS : Response.RESPONSE_RESULT_ERROR;

responseContent.setResponseResult(result);

} else

responseContent.setResponseResult(Response.RESPONSE_RESULT_ERROR);

return responseContent.generateResponse();

}

/**

* 导入客户信息

*

* @param file 保存有客户信息的文件

* @return 返回一个map，其中：key 为 result表示操作的结果，包括：success 与

* error；key为total表示导入的总条数；key为available表示有效的条数

*/

@RequestMapping(value = "importCustomer", method = RequestMethod.POST)

public

@ResponseBody

Map importCustomer(@RequestParam("file") MultipartFile file) throws CustomerManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

String result = Response.RESPONSE_RESULT_SUCCESS;

// 读取文件内容

int total = 0;

int available = 0;

if (file == null)

result = Response.RESPONSE_RESULT_ERROR;

Map importInfo = customerManageService.importCustomer(file);

if (importInfo != null) {

total = (int) importInfo.get("total");

available = (int) importInfo.get("available");

}

responseContent.setResponseResult(result);

responseContent.setResponseTotal(total);

responseContent.setCustomerInfo("available", available);

return responseContent.generateResponse();

}

/**

* 导出客户信息

*

* @param searchType 查找类型

* @param keyWord 查找关键字

* @param response HttpServletResponse

*/

@SuppressWarnings("unchecked")

@RequestMapping(value = "exportCustomer", method = RequestMethod.GET)

public void exportCustomer(@RequestParam("searchType") String searchType, @RequestParam("keyWord") String keyWord,

HttpServletResponse response) throws CustomerManageServiceException, IOException {

String fileName = "customerInfo.xlsx";

List customers = null;

Map queryResult = query(searchType, keyWord, -1, -1);

if (queryResult != null) {

customers = (List) queryResult.get("data"pICCgR);

}

// 获取生成的文件

File file = customerManageService.exportCustomer(customers);

// 写出文件

if (file != null) {

// 设置响应头

response.addHeader("Content-Disposition", "attachment;filename=" + fileName);

FileInputStream inputStream = new FileInputStream(file);

OutputStream outputStream = response.getOutputStream();

byte[] buffer = new byte[8192];

int len;

while ((len = inputStream.read(buffer, 0, buffehttp://r.length)) > 0) {

outputStream.write(buffer, 0, len);

outputStream.flush();

}

inputStream.close();

outputStream.close();

}

}

}

商品出入库管理请求:

/**

* 商品出入库管理请求

*

* @author yy

*/

@Controller

@RequestMapping(value = "stockRecordManage")

public class StockRecordManageHandler {

@Autowired

private StockRecordManageService stockRecordManageService;

/**

* 货物出库操作

*

* @param customerID 客户ID

* @param goodsID 货物ID

* @param repositoryIDStr 仓库ID

* @param number 出库数量

* @return 返回一个map，key为result的值表示操作是否成功

*/

@RequestMapping(value = "stockOut", method = RequestMethod.POST)

public

@ResponseBody

Map stockOut(@RequestParam("customerID") Integer customerID,

@RequestParam("goodsID") Integer goodsID,

@RequestParam(value = "repositoryID", required = false) String repositoryIDStr,

@RequestParam("number") long number) throws StockRecordManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

String result = Response.RESPONSE_RESULT_ERROR;

boolean authorizeCheck = true;

boolean argumentCheck = true;

Integer repositoryID = null;

// 参数检查

if (repositoryIDStr != null) {

if (StringUtils.isNumeric(repositoryIDStr)) {

repositoryID = Integer.valueOf(repositoryIDStr);

} else {

argumentCheck = false;

responseContent.setResponseMsg("request argument error");

}

}

// 获取 session 中的信息

Subject currentUser = SecurityUtils.getSubject();

Session session = currentUser.getSession();

UserInfoDTO userInfo = (UserInfoDTO) session.getAttribute("userInfo");

String personInCharge = userInfo == null ? "none" : userInfo.getUserName();

Integer repositoryIDBelong = userInfo == null ? -1 : userInfo.getRepositoryBelong();

// 设置非管理员请求的仓库ID

if (!currentUser.hasRole("systemAdmin")) {

if (repositoryIDBelong < 0) {

authorizeCheck = false;

responseContent.setResponseMsg("You are not authorized");

} else {

repositoryID = repositoryIDBelong;

}

}

if (authorizeCheck && argumentCheck) {

if (stockRecordManageService.stockOutOperation(customerID, goodsID, repositoryID, number, personInCharge))

result = Response.RESPONSE_RESULT_SUCCESS;

}

// 设置 Response

responseContent.setResponseResult(result);

return responseContent.generateResponse();

}

/**

* 货物入库操作

*

* @param supplierID 供应商ID

* @param goodsID 货物ID

* @param repositoryIDStr 仓库ID

* @param number 入库数目

* @return 返回一个map，key为result的值表示操作是否成功

*/

@RequestMapping(value = "stockIn", method = RequestMethod.POST)

public

@ResponseBody

Map stockIn(@RequestParam("supplierID") Integer supplierID,

@RequestParam("goodsID") Integer goodsID,

@RequestParam(value = "repositoryID", required = false) String repositoryIDStr,

@RequestParam("number") long number) throws StockRecordManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

String result = Response.RESPONSE_RESULT_ERROR;

boolean authorizeCheck = true;

boolean argumentCheck = true;

Integer repositoryID = null;

// 参数检查

if (repositoryIDStr != null) {

if (StringUtils.isNumeric(repositoryIDStr)) {

repositoryID = Integer.valueOf(repositoryIDStr);

} else {

argumentCheck = false;

responseContent.setResponseMsg("request argument error");

}

}

// 获取session中的信息

Subject currentUser = SecurityUtils.getSubject();

Session session = currentUser.getSession();

UserInfoDTO userInfo = (UserInfoDTO) session.getAttribute("userInfo");

String personInCharge = userInfo == null ? "none" : userInfo.getUserName();

Integer repositoryIDBelong = userInfo == null ? -1 : userInfo.getRepositoryBelong();

// 设置非管理员请求的仓库ID

if (!currentUser.hasRole("systemAdmin")) {

if (repositoryIDBelong < 0) {

authorizeCheck = false;

responseContent.setResponseMsg("You are not authorized");

} else {

repositoryID = repositoryIDBelong;

}

}

// 执行 Service

if (authorizeCheck && argumentCheck) {

if (stockRecordManageService.stockInOperation(supplierID, goodsID, repositoryID, number, personInCharge)) {

result = Response.RESPONSE_RESULT_SUCCESS;

}

}

// 设置 Response

responseContent.setResponseResult(result);

return responseContent.generateResponse();

}

/**

* 查询出入库记录

*

* @param searchType 查询类型（查询所有或仅查询入库记录或仅查询出库记录）

* @param repositoryIDStr 查询记录所对应的仓库ID

* @param endDateStr 查询的记录起始日期

* @param startDateStr 查询的记录结束日期

* @param limit 分页大小

* @param offset 分页偏移值

* @return 返回一个Map，其中：Key为rows的值代表所有记录数据，Key为total的值代表记录的总条数

*/

@SuppressWarnings({"SingleStatementInBlock", "unchecked"})

@RequestMapping(value = "searchStockRecord", method = RequestMethod.GET)

public @ResponseBody

Map getStockRecord(@RequestParam("searchType") String searchType,

@RequestParam("repositoryID") String repositoryIDStr,

@RequestParam("startDate") String startDateStr,

@RequestParam("endDate") String endDateStr,

@RequestParam("limit") int limit,

@RequestParam("offset") int offset) throws ParseException, StockRecordManageServiceException {

// 初始化 Response

Response responseContent = ResponseFactory.newInstance();

List rows = null;

long total = 0;

// 参数检查

String regex = "([0-9]{4})-([0-9]{2})-([0-9]{2})";

boolean startDateFormatCheck = (StringUtils.isEmpty(startDateStr) || startDateStr.matches(regex));

boolean endDateFormatCheck = (StringUtils.isEmpty(endDateStr) || endDateStr.matches(regex));

boolean repositoryIDCheck = (StringUtils.isEmpty(repositoryIDStr) || StringUtils.isNumeric(repositoryIDStr));

if (startDateFormatCheck && endDateFormatCheck && repositoryIDCheck) {

Integer repositoryID = -1;

if (StringUtils.isNumeric(repositoryIDStr)) {

repositoryID = Integer.valueOf(repositoryIDStr);

}

// 转到 Service 执行查询

Map queryResult = stockRecordManageService.selectStockRecord(repositoryID, startDateStr, endDateStr, searchType, offset, limit);

if (queryResult != null) {

rows = (List) queryResult.get("data");

total = (long) queryResult.get("total");

}

} else

responseContent.setResponseMsg("Request argument error");

if (rows == null)

rows = new ArrayList<>(0);

responseContent.setCustomerInfo("rows", rows);

responseContent.setResponseTotal(total);

return responseContent.generateResponse();

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。