SpringBoot之文件操作记录存储服务

已于 2024-05-20 08:36:54 修改
阅读量2.1k 收藏 50
点赞数 41
分类专栏： # 微服务 文章标签： springboot java
于 2024-05-01 21:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34020761/article/details/138373445
版权

概述

应公司安全管理部门政策要求,需要实现文件上传/下载操作的日志记录,经过分析需要在目前平台上基于springboot搭建一套服务供其他应用具体业务调用,其中该服务涉及到的技术支撑：AOP实现异常处理、queue+spring-scheduler异步执行定时任务、Fegin组件进行服务间通信(通过拦截器设置请求头中token认证信息)

功能实现

AOP进行异常处理

(另外基于AOP实现了RBAC-基于角色的的访问控制)

package test.bs.web.aspect;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import test.common.exception.*;
import test.common.util.Page;
import test.common.util.R;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.ModelAndView;

import javax.validation.ConstraintViolationException;
import java.lang.reflect.Method;

/**
 * 
 * @ClassName: ExceptionHandlerAspect
 * @Description: 统一异常处理
 * @author test
 *
 */
@Aspect
@Component
public class ExceptionHandlerAspect {

	private Logger logger = LoggerFactory.getLogger(ExceptionHandlerAspect.class);
	private ObjectMapper om = new ObjectMapper();

	/**
	 * @Title: inController
	 * @Description: 以test开头, controller结尾的包名下任何类的所有方法
	 */	    
	@Pointcut("execution(* test..*.controller..*.*(..))")
	public void inController() {}
	
	/**
	 * @Title: inViewController
	 * @Description: 以test开头, view结尾的包及子包名下任何类的所有方法法(Controller与view 不能相互包含关键字)
	 */	    
	@Pointcut("execution(* test..*.view_controller..*.*(..))")
	public void inViewController() {}
	
	/**
	 * 
	 * @Title: handleAPIControllerMethod
	 * @Description: api 异常处理器
	 * @param pjp
	 * @return
	 * @throws Throwable
	 */
	@Around("inController()")
	public Object handleAPIControllerMethod(ProceedingJoinPoint pjp) throws Throwable {
		Object r;
		try {
			r = pjp.proceed(pjp.getArgs());
		} catch(Exception e) {
			logger.error(e.getMessage());
			e.printStackTrace();
			r  = handleAPIControllerException(pjp, e);
		}
		return r;
	} 
	
	@Around("inViewController()")
	public ModelAndView handleViewControllerMethod(ProceedingJoinPoint pjp) throws Throwable{
		ModelAndView mv;
		try {
			mv = (ModelAndView)pjp.proceed(pjp.getArgs());
		} catch(Exception e) {
			logger.error(e.getMessage());
			e.printStackTrace();
			mv = handleViewControllerException(pjp, e);
		}
		return mv;
	}
	
	/**
	 * 
	 * @Title: handleAPIControllerException
	 * @Description: 具体API异常处理
	 * @param pjp
	 * @param e
	 * @return
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 */
	@SuppressWarnings("unchecked")
	private Object handleAPIControllerException(ProceedingJoinPoint pjp, Throwable e) throws InstantiationException, IllegalAccessException {
		Object r = null;
		MethodSignature signature = (MethodSignature) pjp.getSignature();
		// 获取method对象 
		Method method = signature.getMethod();
		// 获取方法的返回值的类型
		Class returnType=   method.getReturnType();
		
		// 根据自定义常见的异常抛出异常信息
		R<String> eR = getExceptionMessage(e);
		if( returnType.equals(R.class) ) {
        	r = new R(null, eR.getMsg(), eR.getCode());
		} else if( returnType.equals(Page.class)) {
			r = new Page(null, eR.getMsg(), eR.getCode());
		} else {
			r = returnType.newInstance(); // 约定必须有默认的构造函数
		}
		return r;
	}
	
	/**
	 * 
	 * @Title: handleViewControllerException
	 * @Description: 捕获ModelAndView 异常
	 * @param pjp
	 * @param e
	 * @return
	 */
	private ModelAndView handleViewControllerException(ProceedingJoinPoint pjp, Throwable e) {
		ModelAndView mv = new ModelAndView();
		mv.setViewName("error");
		// 根据自定义常见的异常抛出异常信息
		R<String> eR = getExceptionMessage(e);
		mv.addObject("status", eR.getCode())
		.addObject("exception", e.getClass())
		.addObject("error", eR.getData())  
		.addObject("message", eR.getMsg());
		return mv;
	}

	/**
	 *
	 * @Title: getExceptionMessage
	 * @Description: 获取异常信息
	 * @param e
	 * @return
	 */
	private R<String> getExceptionMessage(Throwable e) {
		R<String> rst = new R<>();
		if( e instanceof NullPointerException ){

			rst.setCode(R.FAIL);
			rst.setData(null);
			rst.setMsg(e.getMessage());

		} else if (e instanceof RequestParameter400Exception) {
			rst.setCode(R.INPUT_ERROR_400);
			rst.setData(null);
			rst.setMsg("The system has rejected your operation for the following reason:" + e.getMessage());

		} else if( e instanceof AuthorizationFailedException) {
			rst.setCode(R.NO_LOGIN);
			rst.setData(null);
			rst.setMsg("The system has rejected your operation for the following reason:" + e.getMessage());

		} else if(e instanceof NoPermissioinException) {
			rst.setCode(R.NO_PERMISSION);
			rst.setData(null);
			rst.setMsg("The system has rejected your operation for the following reason:" + e.getMessage());

		} else if( e instanceof NotFoundException) {
			rst.setCode(R.NOT_FOUND);
			rst.setData(null);
			rst.setMsg("The system has rejected your operation for the following reason:" + e.getMessage());
		} 
		...
		return rst;
	}
}

queue+任务调度Scheduler

  • 保存文件操作历史记录到队列(使用线程安全队列LinkedBlockingQueue)
package test.bs.internal.ws.queue;

import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
import test.bs.pojo.po.HistoryRecord;

/**
 * 
 * @ClassName: SaveHistoryRecordsQueue
 * @Description: 暂保存插入数据库DB的历史记录的队列
 *
 */
public class SaveHistoryRecordsQueue {

	/**
	 * 队列大小 
	 */
	private static int QUEUE_MAX_SIZE = 80000;
	
	/**
	 * 共享队列，使用线程安全的Queue，设置队列最大大小=80000:若不设置则超过内存大小则会导致应用因内存不足而崩溃
	 */
	private volatile Queue<FileOpHisRecords> pendingTodoQueue = new LinkedBlockingQueue<>(QUEUE_MAX_SIZE);
	
	private static final Object lockedObj = new Object();
	
	/**
	 * 默认单例,使用volatile以标识获取当前变量时需要从内存获取：volatile的双重检测同步延迟载入模式
	 */
	private static volatile SaveHistoryRecordsQueue INSTANCE;
	
	private SaveHistoryRecordsQueue() {
		if(pendingTodoQueue == null) {
			pendingTodoQueue = new LinkedBlockingQueue<>(QUEUE_MAX_SIZE);
		}
	}
	
	// volatile的双重检测同步延迟载入模式
	public static SaveHistoryRecordsQueue getInstance() {
		if(INSTANCE == null) {
			synchronized (lockedObj) {
				if(INSTANCE == null) {
					INSTANCE = new SaveHistoryRecordsQueue();
				}
			}
		}
		return INSTANCE;
	}

	/**
	 * 
	 * @Title: getPendingTodoQueue
	 * @Description: 获取待处理的队列
	 * @return
	 */
	public Queue<FileOpHisRecords> getPendingTodoQueue() {
		return pendingTodoQueue;
	}	
}
  • 通过使用spring-schedule定时任务调度方式来异步执行队列中的任务以减少DB端的并发负载
package test.bs.internal.ws.schedule;

import java.util.Queue;
import javax.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import com.fasterxml.jackson.databind.ObjectMapper;
import test.bs.internal.ws.queue.SaveHistoryRecordsQueue;
import test.bs.pojo.po.FileOpHisRecords;
import test.bs.service.FileOpHisRecordsService;

/**
 * @ClassName: SaveHistoryRecordsScheduler
 * @Description: 实现异步保存文件操作历史记录排程以减少 DB 的并发负载
 */
@Component
@RefreshScope
public class SaveHistoryRecordsScheduler {

	private Logger logger = LoggerFactory.getLogger(SaveHistoryRecordsScheduler.class);
	
	// 每执行一次排程最多保存操作历史记录的数量
	@Value("${test.bs.per.max.counter:30}")
	private final int maxProcessCounter = 30;

	@Resource
	private FileOpHisRecordsService fileOpHisRecordsService; //实现历史记录插入DB的服务

	@Autowired
	private ObjectMapper om;

	// 设置固定任务间隔频率(每次执行均以上次执行结束时间为参考间隔2s时间再执行)
	@Scheduled(fixedDelay = 2000) //设置2s秒钟執行一次
	protected void fixedRateSchedule() {
		Queue<FileOpHisRecords> queue = PendingToSaveFileOperationHistoryQueue.getInstance().getPendingTodoQueue();
		if (queue != null && !queue.isEmpty()) {
			int counter = 0;

			FileOpHisRecords todoItem = null;
			boolean insertSelective = false;
			while (!queue.isEmpty() && counter < maxProcessCounter) {
				counter++;
				todoItem = queue.peek(); //取队列最先添加队列中的元素(队列遵循先进先出)
				if (todoItem != null) {
					try {
						insertSelective = fileOpHisRecordsService.insertSelective(todoItem);
						if (!insertSelective) {
							// 打印日志
							logger.error("save operation historyRecord to database fail, todoItem: {}", om.writeValueAsString(todoItem));
						}
					} catch(Exception e) {
						logger.error("save operation historyRecord fail", e);
					}
				}
				queue.poll(); //移除当前元素
			}
		}
	}
}

Fegin组件进行服务调用

  • 涉及保存操作历史记录业务的客户端应用需要添加fegin组件以实现远程调用
    • 添加Fegin接口
package test.bs.service.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import test.bs.dto.request.FileOpHisDTO;
import test.bs.service.feign.impl.FileOpHisRecordFeignFallbackImpl;
import test.bs.service.feign.interceptor.TokenInterceptor;
import test.common.util.R;

/**
 * @ClassName: FileOpHisRecordFeign
 * @Description: Fegin接口
 *             configuration = TokenInterceptor.class:TokenInterceptor作为请求拦截器,用于服* 
 * 务间请求时进行安全认证(token)
 * 
 * 注意：SaveHistoryRecordsScheduler保存操作记录方法位于test-internal-ws服务中,并且请求的url* 
 *       是/test/fileHistoryRecord/addHistoryRecord
*/

@FeignClient(value = "test-internal-ws", fallback = FileOpHisRecordFeignFallbackImpl.class, configuration = TokenInterceptor.class)
public interface FileOpHisRecordFeign {

    @PostMapping("/test/fileHistoryRecord/addHistoryRecord")
    R<Boolean> addFileHistoryRecordsOperate(@RequestBody FileOpHisDTO dto);

}
  • 对于平台系统内部web应用(Web应用会自动带token访问),则可以通过Feign关联具体的微服务直接访问,此时Feign发送请求时会先通过拦截器类TokenInterceptor携带Token进行安全认证; 其他情景下发送请求时,则需要在Http请求过程中设置授权头（指定Token） 
    • package test.bs.service.feign.interceptor;

import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import feign.RequestInterceptor;
import feign.RequestTemplate;


/**
 * 
 * @ClassName: TokenInterceptor
 * @Description: Feign默认请求拦截器
 *				请求 Header
 *					Key: Authorization
 *					Value: Bearer + 有效的JWT-Token。
 */
@Component
public class TokenInterceptor implements RequestInterceptor {
	
	private final static Logger logger = LoggerFactory.getLogger(TokenInterceptor.class);

	@Autowired
	ITokenService tokenService;

	@Override
	public void apply(RequestTemplate template) {
		forwordIpInfo(template); //fegin请求时在请求头添加客户端IP信息
		
		// 判断请求头中是否含有token
		if (template.headers().containsKey("Authorization")
				|| template.headers().containsKey("authorization")
				|| template.headers().containsKey("AUTHORIZATION")) {
			logger.info("token existed");
			return;
		}
		
		try {
			String token = null;
			HttpServletRequest httpServletRequest = getHttpServletRequest();
			if( httpServletRequest != null ) { //从请求上下文获取token
				token = getHeaders(getHttpServletRequest()).get("authorization"); //使用小写
			}
			if(StringUtils.isBlank(token) ) {
				// SSO(Single Sign On)单点登录逻辑
				token = tokenService.getOauthTokenStr();
				if( token != null ) {
					String authHeaderStr = "Bearer " + token;
					template.header("Bearer ", authHeaderStr); //请求头加入token
				} else {
					logger.error("get token fail , the token is null");
				}
				logger.info("get token from sso, token: {}", token);
			} else {
				//上下文获取到的token直接加入到请求头
				template.header("Authorization", token);
				logger.info("get token from current user");
			}
		} catch(Exception e) {
			e.printStackTrace();
			logger.error("Get token Exception", e);
		}
	}
	
	/**
	 * 
	 * @Title: forwordIpInfo
	 * @Description: 请求头添加客户端IP信息
	 * @param template
	 */
	private void forwordIpInfo(RequestTemplate template) {
		HttpServletRequest httpServletRequest = getHttpServletRequest();
		if( httpServletRequest != null ) {
			 Map<String, String> headers = getHeaders(getHttpServletRequest());
			 
			 template.header("x-forwarded-for", headers.get("x-forwarded-for"));
			 template.header("x-real-ip", headers.get("x-real-ip"));
			 
		}
	}
	
	private HttpServletRequest getHttpServletRequest() {  
        try {  
            return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();  
        } catch (Exception e) {  
            return null;  
        }  
    }  
      
    private Map<String, String> getHeaders(HttpServletRequest request) {  
        Map<String, String> map = new LinkedHashMap<>();  
        if( request == null ) {
        	return map;
        }
        Enumeration<String> enumeration = request.getHeaderNames();  
        while (enumeration.hasMoreElements()) {  
            String key = enumeration.nextElement();  
            String value = request.getHeader(key);  
            map.put(key, value);  
        }  
        return map;  
    }  
	
}
  • 实现Fegin接口备用类 
    • package test.bs.service.feign.impl;

import test.bs.dto.request.FileOpHisDTO;
import test.bs.service.feign.FileOpHisRecordFeign;
import test.common.util.R;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @ClassName: FileOpHisRecordFeignFallbackImpl
 * @Description: 备用类--当Feign客户端调用远程服务失败时，会使用这个备用类
 */
@Component
public class FileOpHisRecordFeignFallbackImpl implements FileOpHisRecordFeign {

    private final Logger logger = LoggerFactory.getLogger(FileOpHisRecordFeignFallbackImpl.class);

    @Override
    public R<Boolean> addFileHistoryRecordsOperate(FileOpHisDTO dto) {
        logger.error("Call【test-internal-ws -> addFileHistoryRecordsOperate】exception");
        return new R<Boolean>(false, "Call【test-internal-ws -> addFileHistoryRecordsOperate】exception", R.FAIL);

    }
}
  • Feign调用

在需要调用该方法的业务直接调fileOpHisFeign.addFileHistoryRecordsOperate(historyRecordDto)即可实现将文件操作记录存储到数据库,后续可以通过查询将记录以web方式进行展示~

扩展

  • Fegin如何实现负载均衡？

    • Fegin的负载均衡是通过集成Ribbon来实现的,Ribbon是Netflix开源的一个客户端负载均衡器,可以与Fegin无缝集成,为Fegin提供负载均衡能力。
      • Ribbon发起请求流程
        • 首先Ribbon在发起请求前,会从"服务中心"获取服务列表,然后按照一定的负载均衡策略发起请求,从而实现客户端的负载均衡.Ribbon本身也会缓存一份"服务提供者"清单并维护他的有效性,若发现"服务提供者"不可用,则会重新从"服务中心"获取有效的"服务提供者"清单来及时更新
  • Fegin如何实现认证传递？
    • 因为微服务之间通信是不会携带请求相关信息的,所以当我们需要在服务间传递安全认证信息时,常见做法是使用拦截器传递认证信息,我司是通过实现RequestInterceptor接口来定义TokenInterceptor拦截器,在拦截器里将认证信息添加到请求头中,然后将其注册到Fegin的配置中来实现的(详细可见上面添加Fegin接口处代码描述！！！)
  • Fegin如何设置超时和重试？
feign:
  hystrix:
    enabled: true    
  httpclinet: #use okhttp will better
    enabled: false
  okhttp: 
    enabled: true

ribbon:  
  ReadTimeout: 15000  # 15s 读超时
  ConnectTimeout: 15000 # 15s 连接超时
  MaxAutoRetries: 0     #重试次数,我司不允许重试,因为有可能涉及到幂等性问题
  MaxAutoRetriesNextServer: 1
  MaxTotalConnections: 200  # okhttp及http-client最大连接数量默认为200
  MaxConnectionsPerHost: 50 # http-client下默认每台主机默认连接数量为50, okhttp无此配置

  • LinkedBlockingQueue介绍​​​​​​​

    • LinkedBlockingQueue是JUC中的一个线程安全的队列实现。LinkedBlockingQueue通过内部同步机制(wait/notify)确保了线程安全.所以常用于解决多线程环境下的线程安全问题,因此允许多个线程安全地访问同一个队列,而不需要额外的同步控制
    • LinkedBlockingQueue提供了多种阻塞/非阻塞方法来处理队列元素
      • 阻塞方法
        • put()：向队列添加一个元素。如果队列已满，则调用线程将被阻塞，直到有空位或者队列被中断
        • take()：移除并返回队列头部的元素。如果队列为空，则调用线程将被阻塞，直到队列中有元素可用或者队列被中断
        • offer()：在指定的等待时间内尝试向队列添加一个元素。如果队列已满，则线程将等待直到有空位或者超时
        • poll()：在指定的等待时间内尝试移除并返回队列头部的元素。如果队列为空，则线程将等待直到有元素可用或者超时
      • 非阻塞方法(常用与任非务调度场景)
        • offer()：向队列添加一个元素，如果队列已满，则立即返回 false 而不是等待
        • poll()：移除并返回队列头部的元素，如果队列为空则立即返回 null 而不是等待
        • peek()：返回队列头部的元素但不移除它，如果队列为空，则立即返回 null
      • 其他方法
        • size()：返回队列中的元素个数。这个方法通常不是阻塞的，但它可能会返回一个近似值，尤其是在高并发的情况下
        • isEmpty()：检查队列是否为空。这个方法通常也不是阻塞的
    • 常用场景
      • 生产者-消费者问题: LinkedBlockingQueue 是解决生产者-消费者问题的选择之一。生产者线程可以安全地将元素放入队列，而消费者线程可以从队列中安全地取出元素
      • 任务调度: 在任务调度系统中，可以将任务封装为对象放入队列中，由工作线程从队列中取出并执行(也是公司实际业务场景)
      • 缓存实现: LinkedBlockingQueue 可以作为缓存的一种实现，允许多个线程安全地添加和删除缓存项
      • 消息传递: 在线程间通信的应用，LinkedBlockingQueue 可以作为消息传递的媒介
奉先节度使
关注
  • 41
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Springboot项目使用Slf4j将日志保存到本地目录的实现代码
08-19
主要介绍了Springboot项目使用Slf4j将日志保存到本地目录的实现方法，本文通过示例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
JAVA毕业设计之基于springboot的实习管理系统(springboot+mysql)完整源码.zip
04-25
数据持久化：使用JPA（Java Persistence API）与Hibernate进行数据持久化操作，简化数据库交互。 数据库：MySQL作为关系型数据库存储系统数据，如实习生信息、实习岗位信息、实习成绩等。 安全：Spring Security用于...
SpringBoot使用AOP记录接口操作日志
热门推荐
何哥的博客
01-07 2万+
前言：我们项目中可能有这种需求，每个人请求了哪些接口？做了什么事情？参数是什么？重要的接口我们需要记日志以便查找。我们不可能在每个接口中去一一处理，可以借助Spring提供的AOP能力+自定义注解轻松应对。 ...
springboot 实现本地文件存储
sumMStar的博客
02-28 893
SpringBoot默认会挨个从pubic、resources、static里面找是否存在相应的资源，如果有则直接返回。springboot提供了。返回得到一个地址，即可访问。
SpringBoot增加操作日志记录 SpringBoot实现操作日志记录 springboot 操作日志记录 SpringBoot日志记录 SpringBoot spring mvc操作日志记录
半只
12-20 3281
增删改查用的是 mybatis-plus, 如果不是用的 mybatis-plus 需要增加一个 insert 的方法。新增 操作日志，查询 我并没有写 SQL语句，都是用的 mybatis-plus 默认增删改查接口。使用 AOP 切入请求层 记录操作日志并保存。AOP操作日志配置文件。
基于springboot实现一个文件服务器
qq_44525150的博客
11-16 2675
本文介绍了如何使用springboot来搭建一个个人文件服务器。 本系统具有文件上传、下载、预览等基本功能，此外，还实现了回收站，日志统计及基本的权限控制
SpringBoot上传文件并储存到本地（记录）
lpCrazyBoy的博客
12-03 6839
主要是通过【MultipartFile】作为参数类型来实现文件上传的。 1、相关controller代码如下： @RequestMapping(value = "/upload", method = RequestMethod.POST) public String upload(@RequestParam("file")MultipartFile file) { if (Objects.isNull(file) || file.isEmpty()) { //判断非空
springboot 从服务器同步文件到本地
baidu_37302589的博客
08-25 609
springboot 从服务器同步文件到本地。
Springboot开发系统记录操作日志
ybb_ymm的专栏
07-04 1310
持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第5天，点击查看活动详情在我们开发一个系统的时候，遇到问题总要去服务器获取日志，分析日志，这样总感觉会很麻烦，所以想想怎么方便快捷的查看系统的日志信息呢？这边是本篇文章的初衷。日志入库，日志入库也有很多方法，这里只介绍其中一种最为简单的方法——切面日志入库 <dependency> <groupId> org.aspectj</groupId > <artifactId> aspectjw
SpringBoot - 搭建静态资源存储服务器
Maggieq8324的博客
09-08 2886
目录前言环境实现效果具体实现文件上传配置类上传接口上传实现辅助类实体上传测试文件访问配置类项目源码 前言 记录下SpringBoot下静态资源存储服务器的搭建。 环境 win10 + SpringBoot2.5.3 实现效果 文件上传： 文件存储位置： 文件访问： 具体实现 文件上传 配置类 pom.xml <dependency> <groupId>org.springframework.boot</groupId> &l
SpringBoot日志文件
Original0的博客
06-25 856
先获取日志对象，需要使用日志工厂Logger对象是属于org.slf4j包下的。日志工程需要把每个类的类型传递进去，这样打印的时候才知道日志的归属类，方便直观的定位到问题类（也可以自定义名字）。//打印日志 logger . info("i am info");
springboot 对HDFS的文件操作
Vincent2014Linux
09-25 4113
1 项目背景 机器学习平台功能需求之一：对Hadoop文件系统进行操作，实现文件目录的创建、算法组件的删除、修改或上传，算法组件的文件类型暂为jar包，同时一些操作信息记录到MySQL。 2 技术路线 需要做的几个步骤： Springboot对HDFS操作的相关配置 HDFS文件的相关操作业务逻辑 eg: 创建、删除、更新、上传等 文件类型检查，对不符规定的文件限制上传 3 代码实现 首先添加...
JAVA毕业设计之基于springboot的的学生干部管理系统(springboot+mysql)完整源码.zip
04-05
该系统采用了Java作为后端编程语言，使用Spring Boot框架进行快速开发，同时结合MySQL数据库进行数据存储。整个系统分为前端界面和后端接口两大部分，实现了学生干部信息的增删改查、活动记录的管理以及通讯录的查询...
JAVA毕业设计之springboot024企业客户管理系统的设计与实现(springboot+mysql)完整源码.zip
03-24
客户服务管理：包括服务记录的添加、修改、删除和查询。客户交易管理：包括交易记录的添加、修改、删除和查询。用户管理：包括用户的添加、修改、删除和查询。权限管理：包括角色的分配和权限的管理。项目的源代码...
springboot电子招投标系统.zip
04-15
数据库通常选用MySQL或其他关系型数据库来存储招标项目、投标文件和用户资料等数据。 Spring Boot的使用使得项目具有快速搭建和易于部署维护的特点，同时Spring Boot生态系统中丰富的插件和组件支持了系统的快速...
jar包增量更新分析
junlaiyan的专栏
05-16 278
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 908
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 639
本文主要提供用java实现的拼图小游戏源代码。
SpringBoot Validation自定义注解之校验指定最小整数
最新发布
thinkers
05-21 41
1，引入核心关键依赖。
springboot日志怎么分文件存储
03-25
以下是一种将Spring Boot日志分文件存储的方法： 1.添加依赖 在`pom.xml`文件中添加logback依赖： ```xml <groupId>ch.qos.logback <artifactId>logback-classic ``` 2.创建logback.xml文件 在项目的`src/...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值