AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

实战：第四章：java后端日志埋点实现

2023-01-14 1282
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： 实战：第四章：java后端日志埋点实现

前段时间架构让我弄日志埋点，因为其他工作不断延期，而且到现在也没给明确的需求，这里自己手写一套简单的日志埋点：

第一步：引入依赖

<!--aop-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!--log4j-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.3</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.25</version>
</dependency>

第二步：因为公司有自己的日志配置，这里我简单配置一条凑合用就行，在application.properties配置：

#日志文件路径 默认生成文件名：spring.log 为了简单便于学习这里我使用默认的
logging.path=F:/Log4j

第三步：自定义注解：

package com.javaliao.portal.annotations;
import org.springframework.web.bind.annotation.ResponseBody;
import java.lang.annotation.*;
/**
 *  app controller 统一包装注解类
 */
@Target({ElementType.PARAMETER, ElementType.METHOD})//作用在参数和方法上
@Retention(RetentionPolicy.RUNTIME)//运行时注解
@Documented//表明这个注解应该被 javadoc工具记录
@ResponseBody//响应时转JSON格式
public @interface AppController {
  /**
   * 业务描述
   * @return
   */
  String description() default "";
  /**
   * 是否打日志 默认打
   */
  boolean isLog() default true;
}

第四步：拦截用户请求

package com.javaliao.portal.aspect;
import com.alibaba.fastjson.JSON;
import com.javaliao.portal.annotations.AppController;
import com.javaliao.portal.common.CommonResult;
import com.javaliao.portal.model.TbLogVisit;
import com.javaliao.portal.service.ActionService;
import com.javaliao.portal.util.CollectionHelp;
import com.javaliao.portal.util.TimeUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.util.*;
import java.util.concurrent.atomic.AtomicLong;
@Component
@Aspect
@SuppressWarnings("all") //@SuppressWarnings("all")抑制所有警告.@SuppressWarnings注解主要用在取消一些编译器产生的警告对代码左侧行列的遮挡，有时候这会挡住我们断点调试时打的断点
public class AppControllerAspect {
    //注入Service用于把日志保存数据库，实际项目入库采用队列做异步
    @Resource
    private ActionService actionService;
    //日志工厂获取日志对象
    static Logger logger = LoggerFactory.getLogger(AppControllerAspect.class);
    /**
     * ThreadLocal多线程环境下，创建多个副本，各自执行，互不干扰
     */
    //startTime存放开始时间
    ThreadLocal<Map<String, Long >> startTime = new ThreadLocal<>();
    //count存放方法被调用的次数O 使用volatile利用它的三大特性：保证可见性（遵守JMM的可见性），不保证原子性，禁止指令重排
    volatile ThreadLocal<Map<String, Long>> count = new ThreadLocal<>();
    //timeConsuming存放方法总耗时
    ThreadLocal<Map<String, Long >> timeConsuming = new ThreadLocal<>();
    //fromType存放渠道
    ThreadLocal<Map<String, String >> fromType = new ThreadLocal<>();
    //tbLogVisit日志访问对象
    ThreadLocal<TbLogVisit> tbLogVisit = new ThreadLocal<>();
    //Controller层切点
    @Pointcut("@annotation(com.javaliao.portal.annotations.AppController)")
    public void controllerAspectse() {
    }
    //前置通知  用于拦截Controller层记录用户的操作
    @Before("controllerAspectse()")
    public void before(JoinPoint pjp) {
        //初始化
        TbLogVisit tbLogVisit = this.tbLogVisit.get();
        tbLogVisit = new TbLogVisit();
        Map<String, Long> countMap = this.count.get();
        countMap = new HashMap<>();
        this.count.set(countMap);
        Map<String, Long> timeConsumingMap = this.timeConsuming.get();
        timeConsumingMap = new HashMap<>();
        this.timeConsuming.set(timeConsumingMap);
        Map<String, String> fromTypeMap = this.fromType.get();
        fromTypeMap = new HashMap<>();
        this.fromType.set(fromTypeMap);
        Map<String, Long> map = new HashMap<>();
        map.put("startTime",System.currentTimeMillis());
        this.startTime.set(map);
        logger.info("==============前置通知开始:记录用户的操作==============");
        String currentTime = TimeUtils.getCurrentTime("YYYY-MM-dd HH:mm:ss");
        logger.info("请求开始时间:" + currentTime);
        tbLogVisit.setVisitStartTime(new Date());
        String resultString = "";
        // 是否打日志 默认打
        boolean isLog = true;
        try {
            MethodSignature signature = (MethodSignature) pjp.getSignature();
            AppController appController = signature.getMethod().getAnnotation(AppController.class);
            //是否开启日志打印
            isLog = appController.isLog();
            if(isLog){
                //开始打印日志
                HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
                HttpSession session = request.getSession();
                String api = pjp.getTarget().getClass().getName() + "." + pjp.getSignature().getName();
                logger.info("请求API：" + api);
                tbLogVisit.setVisitApi(api);
                String methodDescription = getControllerMethodDescription(pjp);
                logger.info("方法描述：" + methodDescription);
                tbLogVisit.setVisitDescription(methodDescription);
                String ipAddress = InetAddress.getLocalHost().toString().substring(InetAddress.getLocalHost().toString().lastIndexOf("/") + 1);
                logger.info("请求ip："+ ipAddress);
                tbLogVisit.setVisitIpAddress(ipAddress);
                String hostName = InetAddress.getLocalHost().getHostName();
                logger.info("机器名：" + hostName);
                tbLogVisit.setVisitHostName(hostName);
                Enumeration<?> enu = request.getParameterNames();
                String params = "{";
                while (enu.hasMoreElements()) {
                    String paraName = (String) enu.nextElement();
                    params += "\"" + paraName + "\":\"" + request.getParameter(paraName) + "\",";
                }
                String methodParams = params + "}";
                String substring = methodParams.substring(0, methodParams.length() - 2);
                substring = substring + "}";
                logger.info("方法参数：" + substring);
                tbLogVisit.setVisitParams(substring);
                StringBuffer url = request.getRequestURL();
                logger.info("URL：" + url);
                tbLogVisit.setVisitUrl(String.valueOf(url));
            }
        } catch (Exception e) {
            StackTraceElement stackTraceElement2 = e.getStackTrace()[2];
            String reason = "异常：【"+
                    "类名："+stackTraceElement2.getClassName()+";"+
                    "文件："+stackTraceElement2.getFileName()+";"+"行："+
                    stackTraceElement2.getLineNumber()+";"+"方法："
                    +stackTraceElement2.getMethodName() + "】";
            //记录本地异常日志
            logger.error("==============前置通知异常:记录访问异常信息==============");
            String message = e.getMessage() + "|" + reason;
            logger.error("异常信息：",message);
            tbLogVisit.setVisitThrowingErro(message);
            tbLogVisit.setVisitResult("请求发生异常，异常信息：" + message);
        }finally {
            this.tbLogVisit.set(tbLogVisit);
        }
    }
    @Around("controllerAspectse()")
    public Object around(ProceedingJoinPoint pjp)throws Throwable {
        String result = JSON.toJSONString(pjp.proceed());
        logger.info("请求结果：" + result);
        TbLogVisit tbLogVisit = this.tbLogVisit.get();
        tbLogVisit.setVisitResult(result);
        this.tbLogVisit.set(tbLogVisit);
        return CommonResult.success("");
    }
    /**
     * 对Controller下面的方法执行后进行切入，统计方法执行的次数和耗时情况
     *  注意，这里的执行方法统计的数据不止包含Controller下面的方法，也包括环绕切入的所有方法的统计信息
     * @param jp
     */
    @AfterReturning("controllerAspectse()")
    public void afterMehhod(JoinPoint jp) {
        logger.info("==============方法执行完成==============");
        TbLogVisit tbLogVisit = this.tbLogVisit.get();
        try {
            //获取方法名
            String methodName = jp.getSignature().getName();
            //开始统计数量与耗时
            if(count.get().get(methodName) == null){
                //第一次赋值为0
                count.get().put(methodName,0L);
            }
            //使用原子整型进行增值
            AtomicLong atomicInteger = new AtomicLong(count.get().get(methodName));
            //加一 这里暂时不解决ABA问题，仅保证原子性 解决了volatile不保证原子性的问题 getAndIncrement()先返回再加1,incrementAndGet()先加1再返回
            long increment = atomicInteger.incrementAndGet();
            //然后增加新值
            count.get().replace(methodName,increment);
            Long end = System.currentTimeMillis();
            Long total =  end - startTime.get().get("startTime");
            logger.info("执行总耗时为：" +total);
            if(timeConsuming.get().containsKey(methodName)){
                timeConsuming.get().replace(methodName, total);
            }else {
                timeConsuming.get().put(methodName, (total));
            }
            tbLogVisit = this.tbLogVisit.get();
            tbLogVisit.setVisitTimeConsuming(String.valueOf(total));
            String endTime = TimeUtils.getCurrentTime("YYYY-MM-dd HH:mm:ss");
            logger.info("请求结束时间:" + endTime);
            tbLogVisit.setVisitEndTime(new Date());
            /**
             * 从原来的map中将最后的连接点方法给移除了，替换成最终的，避免连接点方法多次进行叠加计算，
             * 由于原来的map受ThreadLocal的保护，这里不支持remove，因此，需要单开一个map进行数据交接
             */
            //重新new一个map
            Map<String, Long> map = new HashMap<>();
            for(Map.Entry<String, Long> entry:timeConsuming.get().entrySet()){
                if(entry.getKey().equals(methodName)){
                    map.put(methodName, total);
                }else{
                    map.put(entry.getKey(), entry.getValue());
                }
            }
            for (Map.Entry<String, Long> entry :count.get().entrySet()) {
                for(Map.Entry<String, Long> entry2 :map.entrySet()){
                    if(entry.getKey().equals(entry2.getKey())){
                        Long num = entry.getValue();
                        logger.info("调用次数：" + num);
                        tbLogVisit.setVisitNum(num);
                    }
                }
            }
            //这里的渠道暂时写死
            Map<String, String> stringMap = fromType.get();
            Map<String, String> fromMap ;
            if(CollectionHelp.isMapNotEmpty(stringMap)){
                fromMap = stringMap;
            }else {
                fromMap = new HashMap<>();
                fromMap.put(methodName,"个人开发电商平台");
            }
            String channel = fromMap.get(methodName);
            logger.info("渠道：" + channel);
            tbLogVisit.setVisitChannel(channel);
        } catch (Exception e) {
            StackTraceElement stackTraceElement2 = e.getStackTrace()[2];
            String reason = "异常：【"+
                    "类名："+stackTraceElement2.getClassName()+";"+
                    "文件："+stackTraceElement2.getFileName()+";"+"行："+
                    stackTraceElement2.getLineNumber()+";"+"方法："
                    +stackTraceElement2.getMethodName() + "】";
            //记录本地异常日志
            logger.error("==============通知异常:记录访问异常信息==============");
            String message = e.getMessage() + "|" + reason;
            logger.error("异常信息：",message);
            tbLogVisit.setVisitThrowingErro(message);
            tbLogVisit.setVisitResult("请求发生异常！！！");
        } finally {
            this.tbLogVisit.set(tbLogVisit);
            //添加日志信息入库
            actionService.insertLogVisit(this.tbLogVisit.get());
        }
    }
    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     */
    public static String getControllerMethodDescription(JoinPoint joinPoint) throws Exception {
        String targetName = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();//目标方法名
        Object[] arguments = joinPoint.getArgs();
        Class targetClass = Class.forName(targetName);
        Method[] methods = targetClass.getMethods();
        String description = "";
        for (Method method:methods) {
            if (method.getName().equals(methodName)){
                Class[] clazzs = method.getParameterTypes();
                if (clazzs.length==arguments.length){
                    description = method.getAnnotation(AppController.class).description();
                    break;
                }
            }
        }
        return description;
    }
}

第五步：业务层发消息：

package com.javaliao.portal.service.impl;
import com.javaliao.portal.mapper.TbLogVisitMapper;
import com.javaliao.portal.model.TbLogVisit;
import com.javaliao.portal.service.ActionService;
import com.javaliao.portal.util.ActiveMQUtil;
import net.sf.json.JSONObject;
import org.apache.activemq.command.ActiveMQMapMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.jms.*;
@Service
public class ActionServiceImpl implements ActionService {
    @Autowired
    TbLogVisitMapper tbLogVisitMapper;
    @Autowired
    ActiveMQUtil activeMQUtil;
    @Override
    public void insertLogVisit(TbLogVisit tbLogVisit) {
        try {
            // 连接消息服务器
            Connection connection = activeMQUtil.getConnection();
            connection.start();
            //第一个值表示是否使用事务，如果选择true，第二个值相当于选择0
            Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
            // 发送消息
            Queue testqueue = session.createQueue("LOG_VISIT_QUEUE");
            MessageProducer producer = session.createProducer(testqueue);
            MapMessage mapMessage=new ActiveMQMapMessage();
            String toString = JSONObject.fromObject(tbLogVisit).toString();
            mapMessage.setString("tbLogVisit",toString);
            producer.setDeliveryMode(DeliveryMode.PERSISTENT);
            producer.send(mapMessage);
            session.commit();// 事务型消息，必须提交后才生效
            connection.close();
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

第六步：接收消息执行添加业务：

package com.javaliao.portal.listener;
import com.javaliao.portal.log4j.BaseLogger;
import com.javaliao.portal.model.TbLogVisit;
import com.javaliao.portal.service.ActionService;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
import javax.jms.JMSException;
import javax.jms.MapMessage;
@Component
public class LogVisitListener {
    @Autowired
    ActionService actionService;
    @JmsListener(containerFactory = "jmsQueueListener" ,destination = "LOG_VISIT_QUEUE")
    public void consumeLogResult(MapMessage mapMessage){
        try {
            String object = mapMessage.getString("tbLogVisit");
            JSONObject jsonObject = new JSONObject().fromObject(object);
            TbLogVisit logVisit = (TbLogVisit) JSONObject.toBean(jsonObject, TbLogVisit.class);
            int count = actionService.insertLog(logVisit);
            if(count < 1){
                BaseLogger.info("日志更新失败");
            }
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

执行业务：

package com.javaliao.portal.service.impl;
import com.javaliao.portal.mapper.TbLogVisitMapper;
import com.javaliao.portal.model.TbLogVisit;
import com.javaliao.portal.model.TbLogVisitExample;
import com.javaliao.portal.service.ActionService;
import com.javaliao.portal.util.ActiveMQUtil;
import com.javaliao.portal.util.CollectionHelp;
import com.javaliao.portal.util.NumberUtils;
import net.sf.json.JSONObject;
import org.apache.activemq.command.ActiveMQMapMessage;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.jms.*;
import java.util.Date;
import java.util.List;
@Service
public class ActionServiceImpl implements ActionService {
    @Autowired
    TbLogVisitMapper tbLogVisitMapper;
    //这里去掉了之前发消息的代码
    /**
     * 添加日志信息入库
     * @param tbLogVisit
     * @return
     */
    @Override
    public int insertLog(TbLogVisit tbLogVisit) {
        tbLogVisit.setUpdateTime(new Date());
        int count = 0;
        //如果有异常直接添加
        if(StringUtils.isNoneEmpty(tbLogVisit.getVisitThrowingErro())){
            tbLogVisit.setCreateTime(new Date());
            count = tbLogVisitMapper.insert(tbLogVisit);
        }else {
            String visitIpAddress = tbLogVisit.getVisitIpAddress();
            String visitApi = tbLogVisit.getVisitApi();
            TbLogVisitExample tbLogVisitExample = new TbLogVisitExample();
            TbLogVisitExample.Criteria criteria = tbLogVisitExample.createCriteria();
            criteria.andVisitIpAddressEqualTo(visitIpAddress);
            criteria.andVisitApiEqualTo(visitApi);
            List<TbLogVisit> tbLogVisits = tbLogVisitMapper.selectByExample(tbLogVisitExample);
            if(CollectionHelp.isNotEmpty(tbLogVisits)){
                Long nums = 0L;
                Double sums = 0D;
                for (TbLogVisit logVisit : tbLogVisits) {
                    //统计调用次数
                    Long visitNum = logVisit.getVisitNum();
                    nums = tbLogVisit.getVisitNum() + visitNum;
                    //统计耗时
                    Double visitTimeConsumingData = NumberUtils.Double(logVisit.getVisitTimeConsuming());
                    Double visitTimeConsumingParam = NumberUtils.Double(tbLogVisit.getVisitTimeConsuming());
                    Double sum = visitTimeConsumingData + visitTimeConsumingParam;
                    sums = sums + sum;
                }
                Double numDouble = NumberUtils.Double(String.valueOf(nums));
                //统计平均耗时
                Double avg = sums / numDouble;
                tbLogVisit.setVisitTimeConsuming(avg.toString());
                tbLogVisit.setVisitNum(nums);
                count = tbLogVisitMapper.updateByExample(tbLogVisit,tbLogVisitExample);
            }else {
                tbLogVisit.setCreateTime(new Date());
                count = tbLogVisitMapper.insert(tbLogVisit);
            }
        }
        return count;
    }
}

这里提供我写的项目地址：https://github.com/javaliao/personalmall


一开始没有设计好，后面强迫改动，导致访客的开始时间和结束时间都是最近一次的，不过我把每次请求的耗时改为平均耗时，勉强达到效果（不过有些请求异常的耗时时间长的就比较影响耗时统计了，唉不说了，最开始没有设计好，也算勉强了），效率也不算太差，不会太影响性能，

 

文章标签：
日志服务
Java
关键词：
java日志服务
Java后端
Java实战
Java日志
后端实战
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
我是廖志伟
目录
相关文章
心疼你的一切
|
6天前
|
XML JSON Java
Java中Log级别和解析
日志级别定义了日志信息的重要程度，从低到高依次为：TRACE（详细调试）、DEBUG（开发调试）、INFO（一般信息）、WARN（潜在问题）、ERROR（错误信息）和FATAL（严重错误）。开发人员可根据需要设置不同的日志级别，以控制日志输出量，避免影响性能或干扰问题排查。日志框架如Log4j 2由Logger、Appender和Layout组成，通过配置文件指定日志级别、输出目标和格式。
心疼你的一切
31 2
卓伊凡
|
2月前
|
Java Maven
java项目中jar启动执行日志报错：no main manifest attribute, in /www/wwwroot/snow-server/z-server.jar-jar打包的大小明显小于正常大小如何解决
在Java项目中，启动jar包时遇到“no main manifest attribute”错误，且打包大小明显偏小。常见原因包括：1) Maven配置中跳过主程序打包；2) 缺少Manifest文件或Main-Class属性。解决方案如下：
卓伊凡
645 8
java项目中jar启动执行日志报错：no main manifest attribute, in /www/wwwroot/snow-server/z-server.jar-jar打包的大小明显小于正常大小如何解决
天下无贼001
|
3月前
|
缓存 安全 前端开发
构建高效后端服务：从理论到实战
在数字化浪潮的推动下，后端服务成为了支撑现代互联网应用的核心。本文旨在揭示如何打造一个既可靠又高效的后端系统，从基础架构设计、代码组织、性能优化到安全防护，全方位解析后端开发的艺术。通过实际代码示例和深入浅出的解释，引导读者理解并掌握后端开发的关键技术点。
天下无贼001
94 6
小王老师呀
|
3月前
|
Java Maven Spring
超实用的SpringAOP实战之日志记录
【11月更文挑战第11天】本文介绍了如何使用 Spring AOP 实现日志记录功能。首先概述了日志记录的重要性及 Spring AOP 的优势，然后详细讲解了搭建 Spring AOP 环境、定义日志切面、优化日志内容和格式的方法，最后通过测试验证日志记录功能的准确性和完整性。通过这些步骤，可以有效提升系统的可维护性和可追踪性。
小王老师呀
51 1
mrq4nk6ni2neg
|
3月前
|
存储 SQL 数据库
深入浅出后端开发之数据库优化实战
【10月更文挑战第35天】在软件开发的世界里，数据库性能直接关系到应用的响应速度和用户体验。本文将带你了解如何通过合理的索引设计、查询优化以及恰当的数据存储策略来提升数据库性能。我们将一起探索这些技巧背后的原理，并通过实际案例感受优化带来的显著效果。
mrq4nk6ni2neg
70 4
土木林森
|
3月前
|
运维 NoSQL Java
后端架构演进：微服务架构的优缺点与实战案例分析
【10月更文挑战第28天】本文探讨了微服务架构与单体架构的优缺点，并通过实战案例分析了微服务架构在实际应用中的表现。微服务架构具有高内聚、低耦合、独立部署等优势，但也面临分布式系统的复杂性和较高的运维成本。通过某电商平台的实际案例，展示了微服务架构在提升系统性能和团队协作效率方面的显著效果，同时也指出了其带来的挑战。
土木林森
119 4
lqj_本人
|
3月前
|
JavaScript API 开发工具
＜大厂实战场景＞ ~ Flutter&鸿蒙next 解析后端返回的 HTML 数据详解
本文介绍了如何在 Flutter 中解析后端返回的 HTML 数据。首先解释了 HTML 解析的概念，然后详细介绍了使用 `http` 和 `html` 库的步骤，包括添加依赖、获取 HTML 数据、解析 HTML 内容和在 Flutter UI 中显示解析结果。通过具体的代码示例，展示了如何从 URL 获取 HTML 并提取特定信息，如链接列表。希望本文能帮助你在 Flutter 应用中更好地处理 HTML 数据。
lqj_本人
157 1
mzlogin
|
4月前
|
人工智能 Oracle Java
解决 Java 打印日志吞异常堆栈的问题
前几天有同学找我查一个空指针问题，Java 打印日志时，异常堆栈信息被吞了，导致定位不到出问题的地方。
mzlogin
78 2
lqj_本人
|
3月前
|
JSON Dart 数据格式
＜大厂实战场景＞ ~ flutter&鸿蒙next处理后端返回来的数据的转义问题
在 Flutter 应用开发中，处理后端返回的数据是常见任务，尤其涉及转义字符时。本文详细探讨了如何使用 Dart 的 `dart:convert` 库解析包含转义字符的 JSON 数据，并提供了示例代码和常见问题的解决方案，帮助开发者有效处理数据转义问题。
lqj_本人
193 0
游客moiomvrp3vyac2
|
3月前
|
前端开发 JavaScript NoSQL
探索后端开发之旅：从基础到高级实战
【10月更文挑战第24天】在这个数字时代的浪潮中，后端开发如同一座巨大的宝藏岛，等待着勇敢的探险者去发掘。本文将作为你的藏宝图，引领你从浅滩走向深海，探索后端开发的广阔天地。无论你是初心者还是资深开发者，这篇文章都将为你提供价值连城的知识和技能。准备好了吗？让我们启航，一起构建强大、高效、安全的后端系统！
游客moiomvrp3vyac2
52 0

热门文章

最新文章

  • 1
    如何配置 Java 环境变量：设置 JAVA_HOME 和 PATH
  • 2
    Java社招面试中的高频考点：Callable、Future与FutureTask详解
  • 3
    自研Java框架 Sunrays-Framework使用教程「博客之星」
  • 4
    接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
  • 5
    Java快速入门之数组、方法
  • 6
    Java小抄 使用StopWatch输出执行耗时
  • 7
    【潜意识Java】使用 Ruoyi 框架开发企业级应用，从零开始的实践指南和分析问题
  • 8
    Java中的this关键字详解：深入理解与应用
  • 9
    Java 面向对象编程的三大法宝：封装、继承与多态
  • 10
    深入理解 Java JDK —— 让我们从基础到进阶
  • 1
    【04】Java+若依+vue.js技术栈实现钱包积分管理系统项目-若依框架二次开发准备工作-以及建立初步后端目录菜单列-优雅草卓伊凡商业项目实战
    44
  • 2
    微信小程序与Java后端实现微信授权登录功能
    115
  • 3
    【Java若依框架】RuoYi-Vue的前端和后端配置步骤和启动步骤
    283
  • 4
    Java后端开发-使用springboot进行Mybatis连接数据库步骤
    52
  • 5
    记录一次后端接口抖动的排查过程
    48
  • 6
    网安入门之MySQL后端基础
    64
  • 7
    网安入门之PHP后端基础
    45
  • 8
    圈子社交app前端+后端源码，uniapp社交兴趣圈子开发，框架php圈子小程序安装搭建
    310
  • 9
    婚恋交友系统平台 相亲交友平台系统 婚恋交友系统APP 婚恋系统源码 婚恋交友平台开发流程 婚恋交友系统架构设计 婚恋交友系统前端/后端开发 婚恋交友系统匹配推荐算法优化
    167
  • 10
    后端开发中的性能优化策略
    91

    • 相关课程

    更多
  • 5天玩转Java面向对象编程
  • Java开发工具
  • Java 虚拟机原理
  • Java Web项目实战 - 图书商城
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发

    • 相关电子书

    更多
  • PostgresChina2018_赖思超_PostgreSQL10_hash索引的WAL日志修改版final
  • Kubernetes下日志实时采集、存储与计算实践
  • 日志数据采集与分析对接

    • 相关实验场景

    更多
  • 使用CloudLens管理SLS日志采集
  • 使用CloudLens采集PolarDB日志并进行审计分析
  • 使用CloudLens采集RDS日志并进行审计分析
  • 使用日志服务SLS进行OSS可观测分析
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
    • 下一篇
    PAI Model Gallery 支持云上一键部署 DeepSeek-V3、DeepSeek-R1 系列模型