活动

天翼云最新优惠活动,涵盖免费试用,产品折扣等,助您降本增效!
查看全部活动
热门活动
  • 免费体验DeepSeek,上天翼云息壤 NEW 新老用户均可免费体验2500万Tokens,限时两周
  • 云上钜惠 HOT 爆款云主机全场特惠,更有万元锦鲤券等你来领!
  • 算力套餐 HOT 让算力触手可及
  • 天翼云脑AOne NEW 连接、保护、办公,All-in-One!
  • 一键部署Llama3大模型学习机 0代码一键部署,预装最新主流大模型Llama3与StableDiffusion
  • 中小企业应用上云专场 产品组合下单即享折上9折起,助力企业快速上云
  • 息壤高校钜惠活动 NEW 天翼云息壤杯高校AI大赛,数款产品享受线上订购超值特惠
  • 天翼云电脑专场 HOT 移动办公新选择,爆款4核8G畅享1年3.5折起,快来抢购!
  • 天翼云奖励推广计划 加入成为云推官,推荐新用户注册下单得现金奖励
免费活动
  • 免费试用中心 HOT 多款云产品免费试用,快来开启云上之旅
  • 天翼云用户体验官 NEW 您的洞察,重塑科技边界

智算服务

打造统一的产品能力,实现算网调度、训练推理、技术架构、资源管理一体化智算服务
智算云(DeepSeek专区)
科研助手
  • 算力商城
  • 应用商城
  • 开发机
  • 并行计算
算力互联调度平台
  • 应用市场
  • 算力市场
  • 算力调度推荐
一站式智算服务平台
  • 模型广场
  • 体验中心
  • 服务接入
智算一体机
  • 智算一体机
大模型
  • DeepSeek-R1-昇腾版(671B)
  • DeepSeek-R1-英伟达版(671B)
  • DeepSeek-V3-昇腾版(671B)
  • DeepSeek-R1-Distill-Llama-70B
  • DeepSeek-R1-Distill-Qwen-32B
  • Qwen2-72B-Instruct
  • StableDiffusion-V2.1
  • TeleChat-12B

应用商城

天翼云精选行业优秀合作伙伴及千余款商品,提供一站式云上应用服务
进入甄选商城进入云市场创新解决方案
办公协同
  • WPS云文档
  • 安全邮箱
  • EMM手机管家
  • 智能商业平台
财务管理
  • 工资条
  • 税务风控云
企业应用
  • 翼信息化运维服务
  • 翼视频云归档解决方案
工业能源
  • 智慧工厂_生产流程管理解决方案
  • 智慧工地
建站工具
  • SSL证书
  • 新域名服务
网络工具
  • 翼云加速
灾备迁移
  • 云管家2.0
  • 翼备份
资源管理
  • 全栈混合云敏捷版(软件)
  • 全栈混合云敏捷版(一体机)
行业应用
  • 翼电子教室
  • 翼智慧显示一体化解决方案

合作伙伴

天翼云携手合作伙伴,共创云上生态,合作共赢
天翼云生态合作中心
  • 天翼云生态合作中心
天翼云渠道合作伙伴
  • 天翼云代理渠道合作伙伴
天翼云服务合作伙伴
  • 天翼云集成商交付能力认证
天翼云应用合作伙伴
  • 天翼云云市场合作伙伴
  • 天翼云甄选商城合作伙伴
天翼云技术合作伙伴
  • 天翼云OpenAPI中心
  • 天翼云EasyCoding平台
天翼云培训认证
  • 天翼云学堂
  • 天翼云市场商学院
天翼云合作计划
  • 云汇计划
天翼云东升计划
  • 适配中心
  • 东升计划
  • 适配互认证

开发者

开发者相关功能入口汇聚
技术社区
  • 专栏文章
  • 互动问答
  • 技术视频
资源与工具
  • OpenAPI中心
开放能力
  • EasyCoding敏捷开发平台
培训与认证
  • 天翼云学堂
  • 天翼云认证
魔乐社区
  • 魔乐社区

支持与服务

为您提供全方位支持与服务,全流程技术保障,助您轻松上云,安全无忧
文档与工具
  • 文档中心
  • 新手上云
  • 自助服务
  • OpenAPI中心
定价
  • 价格计算器
  • 定价策略
基础服务
  • 售前咨询
  • 在线支持
  • 在线支持
  • 工单服务
  • 建议与反馈
  • 用户体验官
  • 服务保障
  • 客户公告
  • 会员中心
增值服务
  • 红心服务
  • 首保服务
  • 客户支持计划
  • 专家技术服务
  • 备案管家

了解天翼云

天翼云秉承央企使命,致力于成为数字经济主力军,投身科技强国伟大事业,为用户提供安全、普惠云服务
品牌介绍
  • 关于天翼云
  • 智算云
  • 天翼云4.0
  • 新闻资讯
  • 天翼云APP
基础设施
  • 全球基础设施
  • 信任中心
最佳实践
  • 精选案例
  • 超级探访
  • 云杂志
  • 分析师和白皮书
  • 天翼云·创新直播间
市场活动
  • 2025智能云生态大会
  • 2024智算云生态大会
  • 2023云生态大会
  • 2022云生态大会
  • 天翼云中国行
天翼云
  • 活动
  • 智算服务
  • 产品
  • 解决方案
  • 应用商城
  • 合作伙伴
  • 开发者
  • 支持与服务
  • 了解天翼云
    • 关系数据库SQL Server版
    • 企业主机安全
    • 云防火墙
    • CDN加速
    • 物理机
    • GPU云主机
    • 天翼云电脑(政企版)
    • 天翼云电脑(公众版)
    • 云主机备份
    • 弹性云主机
      搜索发现
      关系数据库SQL Server版企业主机安全云防火墙CDN加速物理机GPU云主机天翼云电脑(政企版)天翼云电脑(公众版)云主机备份弹性云主机
    • 文档
    • 控制中心
    • 备案
    • 管理中心
    • 登录
    • 免费注册

    [手写spring](5)实现AOP机制(完结)

    首页 知识中心 其他 文章详情页

    [手写spring](5)实现AOP机制(完结)

    2023-07-03 09:13:10 阅读次数:486

    AOP,java,spring

    目标

            我们实现和原生spring相类似的AOP机制,即通过在切面类中的方法上面通过注解指定要切入的位置。当然,使用方法肯定也要和原生的一样,实现主要的功能。


    自定义注解

            我们首先需要定义@Aspect注解,这个注解用在类上面,表示是一个切面类

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE})
    public @interface Aspect {
        String value() default "";
    }

            然后定义一个@Order注解,用于指定多个切面的顺序问题

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE})
    @Documented
    public @interface Order {
        int value() default Integer.MAX_VALUE;
    }

             定义一个@Before和@After注解,用来指定切入的位置,@AfterReturning,@AfterThrowing相类似的,这里就不写了。感兴趣可以自己扩展,基本改个名字就行

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.METHOD})
    public @interface Before {
        String value();
    }
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.METHOD})
    public @interface After {
        String value();
    }

    自定义JoinPoint

            我们使用spring的AOP的时候,都知道有一个JoinPoint,通过JoinPoint可以获取到各种信息,我们这里也定义一个JoinPoint,当然,我们自定义的就封装一点简单信息。

    public class JoinPoint {
    
        private Method method;
        private Object[] agrs;
        public String getName(){
            return method.getName();
        }
        public Object[] getArgs(){
            return agrs;
        }
    
        public JoinPoint(Method method, Object[] agrs) {
            this.method = method;
            this.agrs = agrs;
        }
    }

             我们通过JoinPoint可以获取到切面方法的名称已有经方法中的参数


    定义存储切面类的集合

            我们定义一个Map来存放切面类,然后再定义一个List来存储切面类的名称。

        private List<String> aspectClassNames;
        private Map<String, Integer> aspectClass;
    
        //代码块初始化集合
        {
            aspectClassNames = new ArrayList<>();
            aspectClass = new HashMap<>();
        }

             这里我们再定义一个Map来对private,protectd,public进行映射

        private Map<String, Integer> map;
    
    {
        map = new HashMap<>();
        map.put("public", 1);
        map.put("private", 2);
        map.put("protect", 4);
    }

    定义MethodInfo内部类

            这个类用来表示method的各种信息,如方法修饰符,返回值,参数等等

    
        /**
         * 一个内部类,用于存储方法的信息
         */
        private class MethodInfo {
            public int modify;
            public String returnType;
            public String methodName;
            public Object[] args;
            public String fullClassName;
    
            public MethodInfo(int modify, String returnType, String methodName, Object[] args, String fullClassName) {
                this.modify = modify;
                this.returnType = returnType;
                this.methodName = methodName;
                this.args = args;
                this.fullClassName = fullClassName;
            }
    
        }

    解析切面表达式

            我们知道,使用AOP,那么肯定就有切面表达式,切面表达式往往比较复杂,并且还支持正则表达式,这里我们就简化一下,简化为 exection(修饰符 返回类型 方法全路径(参数))的形式,我们这里提供一个解析切面表达式的方法,传入一个切面表达式,返回一个MethodInfo内部类对象。

        protected MethodInfo getMethodInfo(String value) {
            int modify = 0;
            String returnType = null;
            String fullClassName = null;
            String methodName = null;
            String[] methodArgs = new String[0];
            try {
                String s = value.substring(value.indexOf("(") + 1, value.lastIndexOf(")")).trim();
                //将多个空格替换为单个空格
                s = s.replaceAll(" +", " ");
                //按照空格分割
                String[] strings = s.split(" ");
                //得到修饰符
                modify = map.get(strings[0]);
                //得到返回类型
                returnType = strings[1];
                //得到方法全路径
                fullClassName = strings[2].substring(0, strings[2].lastIndexOf("."));
                //得到方法名称
                methodName = strings[2].substring(strings[2].lastIndexOf(".") + 1, strings[2].lastIndexOf("("));
                //得到方法参数
                String substring = s.substring(s.lastIndexOf(methodName) + methodName.length() + 1, s.lastIndexOf(")"));
                methodArgs = substring.split(" *, *");
            } catch (Exception e) {
                throw new RuntimeException(value + "解析有误,请查看切面路径是否正确");
            }
            return new MethodInfo(modify, returnType, methodName, methodArgs, fullClassName);
        }

    判断是否为目标方法

            我们通过MethodInfo对象和一个method,判断该method是否为目标方法

        protected boolean isTargetMethod(int modify, String returnType, String name, Object[] paramsType, Method method) {
            //判断方法名是否相等
            if (!method.getName().equals(name)) return false;
            //判断方法修饰符是否一样
            if (method.getModifiers() != modify) return false;
            //判断方法返回值是否相等
            if (!method.getReturnType().getName().equals(returnType)) return false;
            //获取该方法的所有参数
            Class<?>[] parameterTypes = method.getParameterTypes();
            //判断方法参数长度是否相等
            if (parameterTypes.length != paramsType.length) return false;
            //判断顺序和类型是否相同
            for (int i = 0; i < paramsType.length; i++) {
                if (!parameterTypes[i].getName().equals(paramsType[i])) return false;
            }
            return true;
        }

    初始化aspectClass容器

            我们在initSingletonObjects方法中对beanDefinitionMap进行遍历的时候,我们也需要初始化aspectClass,如果是切面类就加入Map

    //将切面类名字和order存入map中
    if (bean.getClass().isAnnotationPresent(Aspect.class)) {
        int order = Integer.MAX_VALUE;
        if (bean.getClass().isAnnotationPresent(Order.class)) {
            order = bean.getClass().getAnnotation(Order.class).value();
        }
        aspectClass.put(name, order);
    }

    对切面类进行排序

            我们按照切面类的优先级来对切面类进行排序,将优先级高的放入前面,这个是在aspectClass的Map初始化完成后进行的

            //将切面类按照order进行排序,存储进list
            List<Map.Entry<String, Integer>> list = new ArrayList<>(aspectClass.entrySet());
            list.sort((o1, o2) -> -o1.getValue().compareTo(o2.getValue()));
            for (Map.Entry<String, Integer> t : list) {
                aspectClassNames.add(t.getKey());
            }

    实现AOP

            经过上面的准备,现在我们已经可以实现AOP机制了,AOP就是通过后置处理器来进行实现的,在后置处理器的postProcessAfterInitialization执行完成后我们就可以进行切面,也就是在我们写的processorAfterMethod中进行。

        protected Object processorAfterMethod(Object o, String beanName) {
            for (String postProcessorName : beanPostProcessorNames) {
                BeanPostProcessor postProcessor = (BeanPostProcessor) singletonObjects.get(postProcessorName);
                Object current = null;
                try {
                    current = postProcessor.postProcessAfterInitialization(o, beanName);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (current != null) {
                    o = current;
                }
            }
            //进行切面
            //对该对象的所有方法进行遍历
            String targetMethodFullName = o.getClass().getCanonicalName();
            Method[] declaredMethods = o.getClass().getDeclaredMethods();
            for (Method declaredMethod : declaredMethods) {
                //对所有切面类进行遍历
                for (String aspectClassName : aspectClassNames) {
                    //对切面类的所有方法进行遍历
                    for (Method method : singletonObjects.get(aspectClassName).getClass().getDeclaredMethods()) {
    //                    System.out.println(o.getClass().getName());
                        //判断切面类方法是否有@before或者@After注解
                        if (method.isAnnotationPresent(Before.class)) {
                            //获取注解配置的value
                            String value = method.getAnnotation(Before.class).value();
                            //得到要进行切面的方法信息
                            MethodInfo methodInfo = getMethodInfo(value);
                            //判断现在的方法是否就是要进行切面
                            if (isTargetMethod(methodInfo.modify, methodInfo.returnType,
                                    methodInfo.methodName, methodInfo.args, declaredMethod) &&
                                    methodInfo.fullClassName.equals(targetMethodFullName)) {
                                //临时变量
                                Object proxyObject = o;
                                //返回的代理对象
                                //更新对象
                                o = Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), new InvocationHandler() {
                                    @Override
                                    public Object invoke(Object proxy, Method targetMethod, Object[] args) throws Throwable {
                                        if (targetMethod.getName().equals(declaredMethod.getName())) {
                                            //先执行我们定义的@Before的方法
                                            method.invoke(singletonObjects.get(aspectClassName), new JoinPoint(targetMethod, args));
                                        }
                                        //执行目标方法,返回代理对象
                                        return targetMethod.invoke(proxyObject, args);
                                    }
                                });
                            }
                        } else if (method.isAnnotationPresent(After.class)) {
                            //获取注解配置的value
                            String value = method.getAnnotation(After.class).value();
                            //得到要进行切面的方法信息
                            MethodInfo methodInfo = getMethodInfo(value);
                            //判断现在的方法是否就是要进行切面
                            if (isTargetMethod(methodInfo.modify, methodInfo.returnType,
                                    methodInfo.methodName, methodInfo.args, declaredMethod) &&
                                    methodInfo.fullClassName.equals(targetMethodFullName)) {
                                //临时变量
                                Object proxyObject = o;
                                //返回的代理对象
                                //更新对象
                                o = Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), new InvocationHandler() {
                                    @Override
                                    public Object invoke(Object proxy, Method targetMethod, Object[] args) throws Throwable {
                                        //执行目标方法,返回代理对象
                                        Object result = targetMethod.invoke(proxyObject, args);
                                        if (targetMethod.getName().equals(declaredMethod.getName())) {
                                            //然后我们定义的@After的方法
                                            method.invoke(singletonObjects.get(aspectClassName), new JoinPoint(targetMethod, args));
                                        }
                                        return result;
                                    }
                                });
                            }
                        }
                    }
                }
            }
            return o;
        }

             我这里比较暴力,就是直接对当前类的所有方法进行判断是否为切面方法,当然,原生spring肯定不是这样的,但是这里我们就不要陷入算法的泥潭,我们重点是理解spring的机制。

            一个注意点,如果我们的类是切面类,那么就不会执行后置构造器,所有我们需要在执行后置处理器之前加入以下代码,其实以前也加了,只不过只考虑了后置处理器 

    //如果是自身就是后置处理器或者是一个切面类,跳过
    if (o instanceof BeanPostProcessor || o.getClass().isAnnotationPresent(Aspect.class)) 
         continue;
    

    测试

            创建一个utils包,里面定义一个CalUtils接口,然后再写一个实现类

    public interface CalUtils {
    
        public int add(int a, int b);
    
        public int sub(int a, int b);
    }
    @Component("utils")
    public class MyCalUtils implements CalUtils{
    
        @Override
        public int add(int a, int b) {
            System.out.println(a + " + " + b + " = " + (a + b));
            return a + b;
        }
    
        @Override
        public int sub(int a, int b) {
            System.out.println(a + " - " + b + " = " + (a - b));
            return a - b;
        }
    }

            创建一个aspect包,里面写3个切面类,用于测试,内容如下

    @Aspect
    @Component
    @Order(300)
    public class MyAspect {
    
        @Before(value = "execution(public    int com.ttpfx.use.utils.MyCalUtils.add(int, int))")
        public void first(JoinPoint joinPoint) {
            System.out.println("切面方法---->before,切入方法名:" + joinPoint.getName() + " 目标方法参数:" + Arrays.toString(joinPoint.getArgs()));
        }
    
        @After(value = "execution(public int com.ttpfx.use.utils.MyCalUtils.add(int, int))")
        public void second(JoinPoint joinPoint) {
            System.out.println("切面方法---->after,切入方法名:" + joinPoint.getName() + " 目标方法参数:" + Arrays.toString(joinPoint.getArgs()));
        }
    
        @After(value = "execution(public int com.ttpfx.use.utils.MyCalUtils.sub(int, int))")
        public void thread(JoinPoint joinPoint) {
            System.out.println("[MyAspect1]切面方法---->after,切入方法名:" + joinPoint.getName() + " 目标方法参数:" + Arrays.toString(joinPoint.getArgs()));
        }
    }
    @Aspect
    @Component
    @Order(100)
    public class MyAspect2 {
        
        @After(value = "execution(public int com.ttpfx.use.utils.MyCalUtils.sub(int, int))")
        public void thread(JoinPoint joinPoint) {
            System.out.println("[MyAspect2]切面方法---->after,切入方法名:" + joinPoint.getName() + " 目标方法参数:" + Arrays.toString(joinPoint.getArgs()));
        }
    }
    @Aspect
    @Component
    @Order(200)
    public class MyAspect3 {
    
        @After(value = "execution(public int com.ttpfx.use.utils.MyCalUtils.sub(int, int))")
        public void thread(JoinPoint joinPoint) {
            System.out.println("[MyAspect3]切面方法---->after,切入方法名:" + joinPoint.getName() + " 目标方法参数:" + Arrays.toString(joinPoint.getArgs()));
        }
    }

            在上面几个类中,我们分配了不同的优先级,并且对方法进行了切入。

            由于在上一篇文章中我们将包扫描路径改了,所以我们要把路径改回来,并且由于我们创建了一些后置处理器,输出特别多,影响查看,我们直接删掉,所以现在的扫描路径和项目结构如下

    @ComponentScan(path = "com.ttpfx.use")
    public class ComponentScanPathConfig {
    }

    [手写spring](5)实现AOP机制(完结)

             测试类中的代码如下

    public class MySpringTest {
    
        public static void main(String[] args) {
            ApplicationContext ioc = new ApplicationContext(ComponentScanPathConfig.class);
            CalUtils utils = ioc.getBean("utils", CalUtils.class);
            utils.sub(1, 2);
            System.out.println("-----------------------");
            utils.add(1, 2);
        }
    }

             控制台输出如下,说明代码没有问题,我们成功实现了AOP

    [手写spring](5)实现AOP机制(完结)


    总结

            到这里,我们spring的核心机制,IOC/DI,AOP,都成功实现了,虽然代码不是特别完善,但是我们的基本功能都是没有问题的,其他就是一些细节性的问题,感兴趣可以自己扩展,最后给出我们自己写的spring的代码下载链接

            项目github地址连接


    手写spring系列 

    [手写spring](1)构建框架,实现包扫描

    [手写spring](2)初始化BeanDefinitionMap

    [手写spring](3)初始化singletonObjects,实现依赖注入

    [手写spring](4)实现后置处理器

    [手写spring](5)实现AOP机制(完结)  

    版权声明:本文内容来自第三方投稿或授权转载,原文地址:https://blog.csdn.net/m0_51545690/article/details/125549292,作者:秃头披风侠.,版权归原作者所有。本网站转在其作品的目的在于传递更多信息,不拥有版权,亦不承担相应法律责任。如因作品内容、版权等问题需要同本网站联系,请发邮件至ctyunbbs@chinatelecom.cn沟通。

    上一篇:[手写spring](2)初始化BeanDefinitionMap

    下一篇:[手写spring](4)实现后置处理器

    相关文章

    2025-05-14 10:02:58

    java项目多端数据同步解决方案

    多端数据同步是指在多个设备(例如桌面应用、移动应用、Web应用)之间保持数据的一致性。

    2025-05-14 10:02:58
    java , Spring , WebSocket , 同步 , 数据 , 版本号
    2025-05-14 10:02:58

    java休眠到指定时间怎么写

    java休眠到指定时间怎么写

    2025-05-14 10:02:58
    java , sleep , Thread , util , 方法
    2025-05-13 09:49:12

    Java学习(动态代理的思想详细分析与案例准备)(1)

    Java学习(动态代理的思想详细分析与案例准备)(1)

    2025-05-13 09:49:12
    java , 代理 , 代码 , 对象 , 接口 , 方法 , 需要
    2025-05-09 08:20:32

    基于IDEA的Maven简单工程创建及结构分析

    通过一个 mvn 命令直接让我们创建一个 Maven 的脚手架。

    2025-05-09 08:20:32
    java , Maven , xml , 创建 , 文件 , 文件夹 , 项目
    2025-05-09 08:20:32

    系统架构——Spring Framework

    Spring Framework 是 Spring 生态圈中最基础的项目。其它所有的项目的都是在它的基础上运行使用。

    2025-05-09 08:20:32
    AOP , Data , Spring , 学习 , 模块
    2025-05-08 09:03:57

    前K个高频元素java

    给定一个非空的整数数组,返回其中出现频率前 前K个高频元素java 高的元素。

    2025-05-08 09:03:57
    java , 元素 , 样例 , 给定
    2025-05-08 09:03:21

    基于spring+jsp+mysql实现的Java web论坛系统【源码+数据库+指导运行】

    本项目是一套基于spring+jsp+mysql实现的Java web论坛系统,主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。

    2025-05-08 09:03:21
    Java , jsp , spring , 功能 , 源码
    2025-05-08 09:03:21

    java Swing学生成绩管理系统【项目源码+数据库脚本】

    本项目是一套基于java Swing开发的学生成绩管理系统,主要针对计算机相关专业的正在做bishe的学生和需要项目实战练习的Java学习者。

    2025-05-08 09:03:21
    java , 学生 , 成绩 , 数据库 , 源码
    2025-05-08 09:03:21

    基于java Swing开发的学生成绩管理系统【项目源码+数据库脚本】

    基于java Swing开发的学生成绩管理系统【项目源码+数据库脚本】

    2025-05-08 09:03:21
    java , Swing , 学生 , 源码
    2025-05-08 09:03:07

    spring Bean的作用域和生命周期

    spring Bean的作用域和生命周期

    2025-05-08 09:03:07
    Bean , method , spring , 作用域 , 配置文件
    查看更多
    推荐标签

    作者介绍

    天翼云小翼
    天翼云用户

    文章

    33564

    阅读量

    5034311

    查看更多

    最新文章

    java休眠到指定时间怎么写

    2025-05-14 10:02:58

    基于IDEA的Maven简单工程创建及结构分析

    2025-05-09 08:20:32

    java中final的用法

    2025-04-11 07:15:54

    使用ZipEntry解压zip文件报错: java.lang.IllegalArgumentException: MALFORMED

    2025-04-09 09:17:07

    总结java中文件拷贝剪切的5种方式-JAVA IO基础总结第五篇

    2025-04-09 09:14:24

    spring boot设置session超时时长(自定义spring boot session超时时长)

    2025-04-09 09:11:38

    查看更多

    热门文章

    在java正则表达式中为什么要对 . 进行两次的转义操作 (\\.)才表示真正的 .

    2023-05-15 10:01:56

    GC是什么? 为什么要有GC?

    2023-05-10 06:02:16

    axios&spring前后端分离传参规范总结

    2023-05-22 08:09:06

    Jsp Ajax之模拟用户注册

    2022-11-17 12:37:24

    定义一个函数,接收三个参数返回一元二次方程

    2023-02-13 07:59:59

    Bean的作用域

    2023-06-07 07:31:19

    查看更多

    热门标签

    linux java python javascript 数组 前端 docker Linux vue 函数 shell git 节点 容器 示例
    查看更多

    相关产品

    弹性云主机

    随时自助获取、弹性伸缩的云服务器资源

    天翼云电脑(公众版)

    便捷、安全、高效的云电脑服务

    对象存储

    高品质、低成本的云上存储服务

    云硬盘

    为云上计算资源提供持久性块存储

    查看更多

    随机文章

    线性表练习之Example007-原地逆置单链表

    java -- 变量初始化顺序

    doubbo+zookeeper服务注册发现

    《springboot实战》第五章 springboot 拦截器

    JAVA本地编译运行出现的找不到类名问题

    cube.js 最新版本的一些特性

    • 7*24小时售后
    • 无忧退款
    • 免费备案
    • 专家服务
    售前咨询热线
    400-810-9889转1
    关注天翼云
    • 权益商城
    • 天翼云APP
    • 天翼云微信公众号
    服务与支持
    • 备案中心
    • 售前咨询
    • 智能客服
    • 自助服务
    • 工单管理
    • 客户公告
    • 涉诈举报
    账户管理
    • 管理中心
    • 订单管理
    • 余额管理
    • 发票管理
    • 充值汇款
    • 续费管理
    快速入口
    • 权益商城
    • 文档中心
    • 最新活动
    • 免费试用
    • 信任中心
    • 天翼云学堂
    云网生态
    • 甄选商城
    • 渠道合作
    • 云市场合作
    了解天翼云
    • 关于天翼云
    • 天翼云APP
    • 服务案例
    • 新闻资讯
    • 联系我们
    热门产品
    • 云电脑
    • 弹性云主机
    • 云电脑政企版
    • 天翼云手机
    • 云数据库
    • 对象存储
    • 云硬盘
    • Web应用防火墙
    • 服务器安全卫士
    • CDN加速
    热门推荐
    • 云服务备份
    • 边缘安全加速平台
    • 全站加速
    • 安全加速
    • 云服务器
    • 云主机
    • 智能边缘云
    • 应用编排服务
    • 微服务引擎
    • 共享流量包
    更多推荐
    • web应用防火墙
    • 密钥管理
    • 等保咨询
    • 安全专区
    • 应用运维管理
    • 云日志服务
    • 文档数据库服务
    • 云搜索服务
    • 数据湖探索
    • 数据仓库服务
    友情链接
    • 中国电信集团
    • 189邮箱
    • 天翼企业云盘
    • 天翼云盘
    ©2025 天翼云科技有限公司版权所有 增值电信业务经营许可证A2.B1.B2-20090001
    公司地址:北京市东城区青龙胡同甲1号、3号2幢2层205-32室
    • 用户协议
    • 隐私政策
    • 个人信息保护
    • 法律声明
    备案 京公网安备11010802043424号 京ICP备 2021034386号