springboot+layui实现文件上传

这里的设计是我们的主表要使用mybatis数据字典插件
数据字典是一种通用的程序设计方法。可以认为，不论什么程序，都是为了处理一定的主体，这里的主体可能是人员、商品（超子）、网页、接口、数据库表、甚至需求分析等等。当主体有很多的属性，每种属性有很多的取值，而且属性的数量和属性取值的数量是不断变化的，特别是当这些数量的变化很快时，就应该考虑引入数据字典的设计方法。

主表（需要上传文件的表）

文件表

pom文件添加集成数据字典

		
			com.github.softwarevax
			dictionary-core
			0.0.2.RELEASE
		
		
			com.github.softwarevax
			starter-dictionary-mybatis
			0.0.2.RELEASE
		

字典配置

 
	 @Bean
	 public DictionaryInterceptor dictionaryInterceptor(DataSource dataSource) {
	     // 数据字典 配置表
	     DatabaseTable config = new DatabaseTable();
	     String[] configColumn = new String[]{"item_name", "item_value", "item_type"};
	     String[] configCondition = new String[]{"1 = 1"};
	     String configTableName = "sys_data";
	     config.setColumn(configColumn);
	     config.setConditions(configCondition);
	     config.setTableName(configTableName);
	     
	     DatabaseLoader dbLoader = new DatabaseLoader(dataSource);
	     dbLoader.addDictionaryTable(config);
	     DictionaryInterceptor interceptor = new DictionaryInterceptor(dbLoader);
	     return interceptor;
	 }

java bean
需要上传文件的表映射

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import com.github.softwarevax.dict.core.Dictionary;
import com.github.softwarevax.dict.mybatis.starter.configuation.annoation.EnableDictionary;

import lombok.Data;
import lombok.EqualsAndHashCode;


/开启数据字典功能
@EnableDictionary
@Data
@EqualsAndHashCode(callSuper = true)
public class PubTest extends Model {

    private static final long serialVersionUID = 1L;

    @TableId(value="id",type=IdType.ASSIGN_UUID)
    private String id;

    private String test;
    
    @Dictionary(table ="sys_data", column = "item_name", value = "item_value",conditions = {"item_type = 11"}, property = "updateUserName")
    private String formKey;
    
    @TableField(exist = false)
    private String updateUserName;
}

添加页面上传文件部分代码

 
				
				

				密级
				

					
					
				
			
				

			

				
				
			

上传文件java bean

import com.baomidou.mybatisplus.extension.activerecord.Model;
import com.github.dreamyoung.mprelation.JoinColumn;
import com.github.dreamyoung.mprelation.ManyToOne;

import java.time.LocalDateTime;
import java.util.Date;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;

import lombok.Data;
import lombok.EqualsAndHashCode;


@Data
@EqualsAndHashCode(callSuper = true)
public class PubUploadFiles extends Model {

    private static final long serialVersionUID = 1L;

    
    @TableId(value = "FILE_ID", type = IdType.ASSIGN_UUID)
    private String fileId;

    
    @TableField("FILE_NAME")
    private String fileName;

    
    @TableField("FILE_TYPE")
    private String fileType;
    
    @TableField("FILE_SIZE")
    private String fileSize;
    
    @TableField("PARENT_ID")
    private String parentId;

    
    @TableField("UPLOAD_BY")
    private String uploadBy;

    
    @TableField("UPLOAD_TIME")
    private Date uploadTime;

    
    @TableField("SECRET_DEGREE")
    private String secretDegree;
    //文件后缀
    @TableField("FILE_EXT")
    private String fileExt;
}

文件列表数据部分前端代码core/uploadfile/list.html

点击添加附件跳转页面代码/core/uploadfile/form.html

上传成功后设定密级页面core/uploadfile/setSecret

    


        

            

                

                   文件密级
                   

                       
                   
               
  
               
               

                    保存
               
           
 
            
        
    

密级下拉框后端代码

//密级小于父页面密级
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jincheng.bean.SysSecretDegree;
import com.jincheng.bean.SysUser;
import com.jincheng.service.ISysSecretDegreeService;

@RestController
public class SysSecretDegreeController {
	@Autowired
	private ISysSecretDegreeService service;
	
	@RequestMapping("/core/syssecretdegree/list")
	public List secretList(UsernamePasswordAuthenticationToken p,String formDegree){
		SysUser user=(SysUser)p.getPrincipal();
		QueryWrapper query=new QueryWrapper();
		String degree="";
		if(formDegree!=null&&formDegree!="") {
			if(Integer.parseInt(formDegree)>Integer.parseInt(user.getSecretDegree())) {
				degree=user.getSecretDegree();
			}else {
				degree=formDegree;
			}
		}else {
			degree=user.getSecretDegree();
		}
		query.le("secret_degree",degree);
		List list = service.list(query);
		return list;
	}
}

上传文件，设定密级，下载，删除等后端代码

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jincheng.bean.PubUploadFiles;
import com.jincheng.service.IPubUploadFilesService;
import com.jincheng.util.JsonResult;
import com.jincheng.util.SecretLabelAPI;
import com.jincheng.util.UtilTool;
import com.yunnan.bean.SecretLabelConfig;


@Controller
public class PubUploadFilesController {
	@Value("${savePath.uploadPath}")//配置文件配置
	private String filePath;
	
	@Autowired
	private IPubUploadFilesService service;
	@Autowired
	private SecretLabelConfig config;
	@GetMapping("/core/uploadfile/form.html")
 	public String showList() {
 		return "core/uploadfile/form.html";
 	} 
	 
	 @PostMapping("/core/uploadfile/setsecret")
	 public JsonResult setSecret(String fileId,String secretDegree,HttpServletRequest request) throws Exception {
		 PubUploadFiles upload=service.getById(fileId);
		 //加标//
		 SecretLabelAPI.enCode(config.secretUser, Integer.valueOf(secretDegree), filePath+"/"+fileId+upload.getFileExt(),config);
		 
		 upload.setSecretDegree(secretDegree);
		 Boolean flg=upload.updateById();
			if(flg) {
				return JsonResult.success("保存成功。");
			}else {
				return JsonResult.error(-1, "保存失败。");
			}	
	}
	 
	@ResponseBody
	@GetMapping("/core/uploadfile/download")
	public void download(String id,HttpServletRequest request,HttpServletResponse response) throws Exception {
		PubUploadFiles upload=service.getById(id);
		//File file=new File(filePath+"/"+id+upload.getFileExt());
		解标///
		String name=SecretLabelAPI.deCode(config.secretUser, filePath+"/"+id+upload.getFileExt(), 3,config);
		File file=new File(name);
		///
		String fileName=upload.getFileName();
		response.setContentType("text/html;charset=UTF-8");
		response.setHeader("Content-disposition","attachment;filename="+fileName);
        OutputStream os = response.getOutputStream();
        FileInputStream fileInputStream = new FileInputStream(file);
        DataInputStream dataInputStream = new DataInputStream(fileInputStream);
        int r;
        while((r=dataInputStream.read())!=-1) {
            os.write(r);
        }
        System.out.println("已下载...");
        fileInputStream.close();
        dataInputStream.close();
        ///下载完后删除脱标文件/
        file.delete();
	}
	
	@PostMapping("/core/uploadfile/clear")
	@ResponseBody
	public void fileClear(String parentId,HttpServletRequest request) {
		QueryWrapper queryWrapper = new QueryWrapper();
		if (parentId != null && !parentId.isEmpty()) {
			queryWrapper.eq("parent_id", parentId);
			queryWrapper.isNull("secret_degree");
			List list=service.list(queryWrapper);
			list.forEach(item->{
				File file=new File(filePath+"/"+item.getFileId()+item.getFileExt());
				file.deleteOnExit();
			});
			service.remove(queryWrapper);
		}
	}
	
	@ResponseBody
	@PostMapping("/core/uploadfile/delete")
	public JsonResult delete(String id,HttpServletRequest request) {
		PubUploadFiles upload=service.getById(id);
		File file=new File(filePath+"/"+id+upload.getFileExt());
		file.deleteOnExit();
		Boolean flg =service.removeById(id);
		if(flg) {
			return JsonResult.success("删除成功。");
		}else {
			return JsonResult.error(-1, "删除失败。");
		}	
	}
	
	@GetMapping("/core/uploadfile/list")
	@ResponseBody
	public JsonResult getList(String fileType,String uid,String secret,HttpServletRequest request) {
		if (uid == null || uid.isEmpty()) {
			return new JsonResult(0, "查看数据", null, 0);
		}
		QueryWrapper queryWrapper = new QueryWrapper();
		if (fileType != null && !fileType.isEmpty()) {
			queryWrapper.eq("file_type", fileType);
		}
		queryWrapper.and(i->i.le("secret_degree",secret).or().isNull("secret_degree"));
		queryWrapper.eq("parent_id", uid);
		List data = service.list(queryWrapper);
		long count =data.size();
		return new JsonResult(0, "查看数据", data, count);
	}
	
	@PostMapping("/core/uploadfile/form")
	@ResponseBody
	public String uploadFile(@RequestParam("fileType") String fileType,@RequestParam("fileKey") String fileKey,HttpServletRequest request) throws Exception {
		if(fileType==null||fileType.equals("")) {
			fileType="1";
		}
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver(request.getSession().getServletContext()); 
        //判断 request 是否有文件上传,即多部分请求   
        if(multipartResolver.isMultipart(request)){   
            //转换成多部分request     
            MultipartHttpServletRequest multiRequest = (MultipartHttpServletRequest) request; 
         // 取得request中的所有文件名 
            Iterator iter = multiRequest.getFileNames();
            while(iter.hasNext()) {
            	 MultipartFile mfile = multiRequest.getFile(iter.next());
            	 String fileName=mfile.getOriginalFilename();
            	 String filePostfix=fileName.substring(fileName.lastIndexOf("."));
            	 String fileId=UtilTool.getUUid();//获取id
            	 String saveName=fileId+filePostfix;
            	 File saveFile = new File(filePath+"/"+saveName);
            	 if(!saveFile.exists()){
                  	saveFile.mkdirs();
                  }
            	 mfile.transferTo(saveFile);
                 PubUploadFiles uploadFile=new PubUploadFiles();
                 判标///
                 Integer degree=SecretLabelAPI.GetSecretId(filePath+"/"+saveName,config);
                 if(degree!=-2) {
                	 uploadFile.setSecretDegree(degree.toString());
                 }
                 ///
                 uploadFile.setFileId(fileId);
                 uploadFile.setFileName(fileName);
                 uploadFile.setParentId(fileKey);
                 uploadFile.setFileType(fileType);
                 double size=mfile.getSize()/1024.0/1024;
                 String total=String.format("%.2f",size)+"MB";
                 uploadFile.setFileSize(total);
                 uploadFile.setFileExt(filePostfix);
                 uploadFile.setUploadTime(new Date());
                 uploadFile.setUploadBy(request.getRemoteUser());
                 uploadFile.insert();
            }
         }
       
        return "上传成功。";
	}
}

文件加标

import java.io.File;
import java.nio.file.Files;
import java.util.Random;

import com.eetrust.label.LabelOperator;
import com.eetrust.label.util.CharacterEnums;
import com.yunnan.bean.SecretLabelConfig;
public class SecretLabelAPI {
	public static LabelOperator labelOperator;
	public static String code;
	
	
	
	public static void initAPI(SecretLabelConfig config) throws Exception{
		if(config.isAddLabel==0){
			System.out.println("----------不加标，暂不需要初始化。-----------");
			return;
		}
		labelOperator = new LabelOperator(config.serverIp,config.serverPort);
		labelOperator.setCharacter(CharacterEnums.UTF_8);
	}
	
	public static Integer enCode(String userId,Integer id,String fileName,SecretLabelConfig config) throws Exception{
		if(labelOperator==null){
			initAPI(config);
		}
		if(config.isAddLabel==0){
			System.out.println("----------暂不加标-----------");
			return -2;
		}
		File file=new File(fileName);
		if(!file.exists()){
			System.out.println("----------文件不存在。-----------");
			return 0;
		}
		System.out.println("-------------path="+file.getAbsolutePath()+"--------");
		int flg=labelOperator.isLabelledFile(file.getAbsolutePath());
		System.out.println("-------------encode是否带标文件:"+flg+"--------");
		if(flg!=0){
			return flg;
		}
		return labelOperator.bindFileLabel(userId, fileName, CreateXml(id), (short) 0);
	}
	
	public static String deCode(String userId,String fileName,Integer state,SecretLabelConfig config) throws Exception{
		if(labelOperator==null){
			initAPI(config);
		}
		File file=new File(fileName);
		Random r=new Random();
		String toFileName=file.getParent()+File.separator+"cp_"+r.nextInt(1000)+file.getName();
		File toFile=new File(toFileName);
		Files.copy(file.toPath(),toFile.toPath());
		if(state==3){
			System.out.println("+++++++++++++是否配置密标："+config.isAddLabel+"+++++++++++++");
			System.out.println("+++++++++++++userid："+userId+"+++++++++++++");
			System.out.println("+++++++++++++name："+toFileName+"+++++++++++++");
			if(config.isAddLabel!=0){
				RemoveLabel(userId, toFileName,config);
			}else{
				System.out.println("-------------不做脱标--------");
			}
		}
		return toFileName;
	}
	
	public static Integer GetSecretId(String file,SecretLabelConfig config) throws Exception{
		if(labelOperator==null){
			initAPI(config);
		}
		if(config.isAddLabel==0){
			System.out.println("-------------配置为不加标，不需要获取密级。--------");
			return -2;
		}
		int flg=labelOperator.isLabelledFile(file);
		System.out.println("-------------获取密标前，是否带标文件:"+flg+"--------");
		if(flg==0){
			return -2;
		}else{
			int a=labelOperator.getFileLevel(file);
			System.out.println("-------------密级ID:"+a+"--------");
			return CoverSecretIdToOA(a);
		}
	}
	
	public static void RemoveLabel(String userId,String file,SecretLabelConfig config) throws Exception{
		if(labelOperator==null){
			initAPI(config);
		}
		if(config.isAddLabel==0){
			System.out.println("-------------配置为不加标，不需要脱标操作。--------");
			return;
		}
		if(!new File(file).exists()){
			return;
		}
		
		int flg=labelOperator.isLabelledFile(file);
		System.out.println("-------------脱标前，是否带标文件:"+flg+"--------");
		if(flg!=0){
			labelOperator.removeFileLabel(userId, file);
		}
	}
	
	private static String CreateXml(Integer secretId){
		String xml=""+CoverSecretId(secretId)+"2";
		return xml;
	}
	
	private static Integer CoverSecretId(Integer id){
		switch(id){
		case -1:
		case 0:
			return 5;
		case 1:
			return 4;
		case 2:
			return 3;
		case 3:
			return 2;
		case 4:
			return 1;
		default:
			return 5;
		}
	}
	
	private static Integer CoverSecretIdToOA(Integer id){
		switch(id){
		case 0:
			return -2;
		case 1:
			return 4;
		case 2:
			return 3;
		case 3:
			return 2;
		case 4:
			return 1;
		case 5:
			return 0;
		default:
			return 0;
		}
	}
	
	public static String SetFileName(String name,String secret){
		if(name.contains("【内部】")||name.contains("【公开】")||name.contains("【秘密】")||name.contains("【机密】")||name.contains("【绝密】")){
			return name.replaceAll("【?(内部|公开|秘密|机密|绝密)】", secret);
		}else{
			return name+secret;
		}
		
	}
	
	public static String CoverSecret(Integer degree){
		 String tmp="";
    	 switch(degree){
    	 case -1:
    		 tmp="【公开】";
    		 break;
    	 case 1:
    		 tmp="【内部】";
    		 break;
    	 case 2:
    		 tmp="【秘密】";
    		 break;
    	 case 3:
    		 tmp="【机密】";
    		 break;
    	 case 4:
    		 tmp="【绝密】";
    		 break;
    	 default:
    		 tmp="【内部】"; 
    	 }
    	 return tmp;
	}
	public static void main(String[] args) throws Exception {
		
	}

}

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@ConfigurationProperties
@Component
public class SecretLabelConfig{
	@Value("${secretLabel.isAddLabel}")
	public  Integer isAddLabel;
	
	@Value("${secretLabel.serverIp}")
	public  String serverIp;
	
	@Value("${secretLabel.serverPort}")
	public  Integer serverPort;
	
	@Value("${secretLabel.secretUser}")
	public  String secretUser;
}

配置文件

secretLabel:
  isAddLabel: 0
  serverIp: 192.168.1.222
  serverPort: 8090
  secretUser: qq

注：由于第一次实现这样的功能，单纯记录一下，可能存在很多问题，请谨慎参考。