【JavaEE进阶之Spring】一分钟让你学会什么是Spring以及如何使用创建Spring

news2024/11/17 5:49:49

前言：
💞💞今天我们正式进入到JavaEE进阶的学习中了，在JavaEE进阶的学习中，我们最主要的就是学习Spring框架。

💟💟那我们从今天就要逐渐从最基础的Spring开始，教会大家什么是Spring以及如何使用。

⭐个人主页：书生♡
gitee主页🙋‍♂：奋斗的小白
博客领域：java编程,前端，算法，强训题目
写作风格：超前知识点，干货，思路讲解，面试题目
支持博主：点赞、收藏⭐、留言💬

在这里插入图片描述

目录

  • 1.Spring框架
    • 1.1 Spring是什么
    • 1.2 Ioc容器
  • 2. 理解Spring Ioc
  • 3.理解DI
  • 4.创建Spring
    • 4.1 创建Maven项目
    • 4.2.添加Spring框架的支持
    • 4.3 添加启动项
  • 5.存储Bean对象
    • 5.1 创建Bean对象
    • 5.2 将bean对象注入到Spring中
  • 6.获取并使⽤ Bean 对象
    • 6.1 获取 Spring 上下⽂对象
    • 6.2 获取 Bean 对象
      • 6.2.1 根据Bean名称（标识）来得到Bean对象
      • 6.2.2 根据Bean类型，来得到Bean对象（容易出错）
      • 6.2.3 根据Bean名称（标识）+类型 来得到Bean对象
    • 6.3 使⽤ Bean 对象
  • 7.存储和使用Bean的总结
  • 8. 面试题之【ApplicationContext VS BeanFactory】

1.Spring框架

1.1 Spring是什么

 我们要学习Spring，那么就要先知道什么是Spring？Spring什么用？

什么是Spring？
定义：我们通常说的Spring其实就是 Spring Framework，也就是Spring框架，可以让程序开发更加简单。
用一句话概括就是：Spring就是一个包含众多工具方法的Ioc容器。

1.2 Ioc容器

 我们在知道Spring是Ioc容器，那么什么是Ioc容器？Ioc是什么？容器又是什么呢？

首先容器：就是一个用来存储某一个/一些物品的装置。
例如：我们之前数据结构学过的List/Map就是一个容器，在JavaEE初阶学过的Tomcat也是一个容器。

List / map —》是一个数据存储容器
Tomcat —》 是一个Web容器

 既然Spring是Ioc容器 ，那么什么是Ioc呢？

IoC = Inversion of Control 翻译成中⽂是“控制反转”的意思，也就是说 Spring 是⼀个“控制反转”的容 器

Ioc是“控制反转”，那么他控制的是什么？反转的又是什么呢？

其实Ioc控制反转的是，对象的生命周期
原本：比如要在A中使用B，传统代码是在A中new B，B的生命周期是由程序员控制的
经过控制反转以后：从Spring拿B对象就行，因为这个时候B对象是由Spring管理的。对生命周期的托管

我们假如设计一个汽车的制造流程:
传统的就是汽车-》车身-》底盘-》轮胎，每一个都是有依赖的。
在这里插入图片描述

public static void main(String[] args) {
    Car car = new Car(20);
    car.run();
}
   
    static class Car {
        private Framework framework;
        public Car(int size) {
            framework = new Framework(size);
        }
        public void run() {
            // 依赖⻋身
            framework.init();
        }
    }
  
    static class Framework {
        private Bottom bottom;
        public Framework(int size) {
            bottom = new Bottom(size);
        }
        public void init() {
            // 依赖底盘
            bottom.init();
        }
    }

 通过部分代码可以看出来，当我们在最底层修改代码的时候，整个代码链都需要进行修改。这样就很麻烦，那么我们怎么解决呢？并且这样的耦合读很高

 现在我们是通过，在每一个类中，创建下一个类，因此我们修改一个其他的就都要修改了，那么我们可以将原来由⾃⼰创建的下级类，改为传递的⽅式（也就是注⼊的⽅式），这样的话我们就不需要修改很多了。
在这里插入图片描述

通过Ioc控制反转的具体的代码实现：

public class App {
    public static void main(String[] args) {
        Tire tire=new Tire(10,"red");
        Bottom bottom=new Bottom(tire);
        Framework framework=new Framework(bottom);
        Car car=new Car(framework);
        car.init();
    }

}

public class Car {
    private Framework framework;

    public Car(Framework framework) {
        this.framework = framework;
    }
    public void init()
    {
        System.out.println("执行Car！！！");
        framework.init();
    }
}

public class Framework {
    private Bottom bottom;

    public Framework(Bottom bottom) {
        this.bottom = bottom;
    }

    public void init()
    {
        System.out.println("执行Framework！！！");
        bottom.init();
    }
}

public class Bottom {

    private  Tire tire;

    public Bottom(Tire tire) {
        this.tire = tire;
    }

    public void  init()
    {
        System.out.println("执行Bottom！！！");
        tire.init();
    }
}

public class Tire {

    private int size = 20;
    private String color;

    public Tire(int size, String color) {
        this.size = size;
        this.color = color;
    }

    public void init() {
        System.out.println("轮胎——size：" + size +
                " | color：" + color);
    }
}

我们来看一下这两个的对比：

在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire
改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car

 传统代码是 Car 控制并创建了Framework，依次往下，⽽改进之后的控制权发⽣的反转，不再是上级对象创建并控制下级对象了，⽽是下级对象注⼊到当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。

Ioc其实就是一个设计的思想，目的就是为了解耦

2. 理解Spring Ioc

我们知道Spring最核心的总结是：Spring是一个包含众多工具方法的Ioc容器。
既然 Spring是一个Ioc（控制反转）容器，那么他就有最基础的两个功能

● 将对象存储到容器中
● 将对象从容器中取出

这个就意味着：我们学习Spring最核心的功能就是学如何将对象存储到Spring，以及怎么讲对象从Spring中取出来。

普通程序：是通过new 对象得方式，想当于每一次使用的时候，才会实现，用完就丢掉了，下次用在实现
Ioc容器：是将对象放到Spring中，使用的时候，直接从容器中取出来就可以了，用完再放回到容器中。

Spring 是⼀个 IoC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身⼜具备了存
储对象和获取对象的能⼒。

3.理解DI

在这里我们不得不提及，另一个根Ioc有关系的词，那就是DI，什么是DI呢?

DI 是 Dependency Injection 的缩写，翻译成中⽂是“依赖注⼊”的意思。

DI：所谓依赖注⼊，就是在程序运⾏期间，动态地将某种依赖关系注⼊到对象之中。（具体的技术）

广义上来讲：
DI和Ioc就是一个东西 是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC容器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦

Ioc：是一种设计思想
DI：是一个具体的实现

4.创建Spring

我们在Servlet中就是创建一个Maven项目去实现的，在我们的Spring中也是一样的，也是通过Maven去实现的。

我们创建一个Spring分为三步：
1.创建一个普通的Maven项目
2.添加Spring框架的支持（spring-context、spring-beans）
3.添加启动类

有很多人不理解bean是什么？其实就是我们Java的对象，就叫做bean

那么我们就往下看每一个步骤是什么样子的。

4.1 创建Maven项目

在这里插入图片描述

在这里插入图片描述

这个就是我们创建好的Maven项目
在这里插入图片描述

4.2.添加Spring框架的支持

我们需要在 Maven的pom.xml中添加依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
    </dependencies>

这段代码大家不要背，大家只需要知道需要添加这个，大家可以把这个代码保存在你的本地，等你需要的时候，直接拿来复制一个就可以了。

在这里插入图片描述

我们添加的依赖有：
spring-context：spring 上下⽂
spring-beans：管理对象的模块。

4.3 添加启动项

在左边的Java下，创建一个类就是我们启动项

在这里插入图片描述

到这里我们的Spring就创建成功了。

5.存储Bean对象

前面给大家说过，Bean其实就是Java对象，只不过我们在这里叫做Bean对象

存储Bean对象分为两个步骤：
1.创建一个Bean对象
2.将创建好的bean对象，注入到Spring中

5.1 创建Bean对象

既然Bean其实就是Java对象
那我们只需要创建一个类就可以了，这样一个bean对象就创建好了

public class User {
    public String Hello()
    {
        return "hello Bean!!!";
    }
}

5.2 将bean对象注入到Spring中

我们需要，在创建好的项⽬中添加 Spring 配置⽂件 spring-config.xml，将此⽂件放到 resources 的根⽬录下
在这里插入图片描述

在spring-config.xml里面写入固定的配置文件，同样的这段代码打击也不需要记住，大家可以保存下来，用的时候直接拿出来就可以了。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
</beans>

接下来，再将 User 对象注册到 Spring 中就可以

我们使用Bean标签来注入到Spring中，id这个名字我们可以随便起，但是class这个名字一定要是我们的包名+类名不可以改变。（没有包的话可以不写）
在这里插入图片描述
到这里我们存储Bean对象就好了

6.获取并使⽤ Bean 对象

我们既然已经将对象存入到容器中，那么就需要将对象从容器中取出来。

获取并使⽤ Bean 对象，分为以下 3 步：

  1. 获取 Spring 上下⽂对象
  2. 获取⼀个指定的 Bean 对象。
  3. 使⽤ Bean 对象。

什么是Spring上下文呢？
 Spring上下文（ApplicationContext）是Spring Framework的核心部分之一，它是一个容器，用于管理应用程序中的所有bean对象。提供了一些基本的功能，如依赖注入（Dependency Injection）。
ApplicationContext可以加载多个配置文件，它会自动扫描所有配置文件中的bean，并将它们加入到容器中，以便在应用程序中使用。在Spring应用程序中，通常会创建一个或多个ApplicationContext对象，每个对象都代表着一个独立的应用程序上下文。

为什么要获取Spring上下文呢？
因为对象都交给 Spring 管理了，所以获取对象要从 Spring 中获取，那么就得先得到Spring 的上下⽂

6.1 获取 Spring 上下⽂对象

我们一般使用ApplicationContext来获取一个Spring上下文对象

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
    //1.获取 Spring 上下⽂对象
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
    }
}

除了ApplicationContext，在以前还会使用BeanFactory，但是这个现在已经过时了

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

public class Test {

    public static void main(String[] args) {
        //1.获取 Spring 上下⽂对象
  //ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        
  BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("springconfig.xml"));

    }
}

6.2 获取 Bean 对象

我们通过getBean来获取Bean

我们也有三种方法去获取Bean对象：
1.根据Bean名称（标识）来得到Bean对象
2.根据Bean类型，来得到Bean对象（容易出错）
3.根据Bean名称（标识）+类型 来得到Bean对象

6.2.1 根据Bean名称（标识）来得到Bean对象

这种需要进行强制转型

public class Test {

    public static void main(String[] args) {
        //1.获取 Spring 上下⽂对象
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        //2.获取Bean对象
        User user=(User) context.getBean("user");

    }
}

在这里插入图片描述

6.2.2 根据Bean类型，来得到Bean对象（容易出错）

第二种方式就是通过 Bean类型来获取

public class Test {

    public static void main(String[] args) {
        //1.获取 Spring 上下⽂对象
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        //2.获取Bean对象
        User user= context.getBean(User.class);
    }
}

但是这种方式，容易出错。当我们当有⼀个类型被重复注册到 spring-config.xml 中时，在使用这种方法获取就会出现问题。
因为是同一个类型的，不知道拿的是哪一个，就会出错。
在这里插入图片描述
在这里插入图片描述

6.2.3 根据Bean名称（标识）+类型 来得到Bean对象

最后一种方式，也是现在最常用的一个方式了，就是通过标识+类型去获取Bean对象

public class Test {

    public static void main(String[] args) {
        //1.获取 Spring 上下⽂对象
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        //2.获取Bean对象
        User user= context.getBean("user",User.class);
    }
}

6.3 使⽤ Bean 对象

我们直接调⽤相应的⽅法就可以使用了

public class Test {

    public static void main(String[] args) {
        //1.获取 Spring 上下⽂对象
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        //2.获取Bean对象
        User user= context.getBean("user",User.class);
        //3.使用Bean对象
        System.out.println(user.Hello());
    }
}

在这里插入图片描述

7.存储和使用Bean的总结

一.创建Maven项目
1.创建一个普通的Maven项目
2.添加Spring框架的支持（spring-context、spring-beans）
3.添加启动类

二. 存对象
1.创建一个Bean对象
2.将创建好的bean对象，注入到Spring中

三. 取对象

  1. 得到 Spring 上下⽂，并读取到 Spring 的配置⽂件。
  2. 获取某⼀个 Bean 对象。
  3. 使⽤ Bean 对象。

在这里插入图片描述

8. 面试题之【ApplicationContext VS BeanFactory】

ApplicationContext 和BeanFactory的功能是一样的，但是ApplicationContext 是 BeanFactory的子类。

相同点：
1.都可以得到Spring的上下文对象
2.都是Spring的顶级接口

不同点：
1.ApplicationContext 是 BeanFactory的子类，其中 BeanFactory 提供了基础的访问容器的能⼒，⽽ ApplicationContext属于 BeanFactory 的⼦类，它除了继承了 BeanFactory 的所有功能之外，它还拥有独特的特性，还添加了对国际化⽀持、资源访问⽀持等⽅⾯。
2.ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，所以以后访问的时候就会很快，BeanFactory 是需要那个才去加载Bean对象，比较慢，因此ApplicationContext 更加轻量

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/634567.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

54、基于51单片机饮水机温度水位控制无线蓝牙APP控制报警系统设计(程序+原理图+PCB源文件+Proteus仿真+参考论文+开题报告+元器件清单等)

54、基于51单片机饮水机温度水位控制无线蓝牙APP控制报警系统设计(程序+原理图+PCB源文件+Proteus仿真+参考论文+开题报告+元器件清单等)

方案的选择 方案一&#xff1a;采用51单片机作为控制核心&#xff0c;配合无线蓝牙模块、水温加热模块继电器开关、基于Dallas单线数字式的DS18B20温度传感器模块、蜂鸣器报警模块、按键模块、LCD1602液晶显示器模块、晶振电路模块、复位电路模块以及电源模块为一体构成无线水…
阅读更多...
winsw使用——将Nginx和Jar包注册到WIN服务

winsw使用——将Nginx和Jar包注册到WIN服务

文章目录 1.winsw介绍2.注册Nginx到win服务2.1 首先将下载的winsw下并改名2.2 nginx-service.exe.config配置2.3 nginx-service.xml配置2.4 nginx-service安装到服务 3.注册Jar包到win服务3.1 复制winsw文件并改名3.2 创建xml配置文件3.3 执行安装命令 1.winsw介绍 Windows Se…
阅读更多...
ChatGPT Prompt Engineering for Developers from DeepLearning.AI

ChatGPT Prompt Engineering for Developers from DeepLearning.AI

链接&#xff1a;https://learn.deeplearning.ai/chatgpt-prompt-eng/lesson/1/introduction In this course, there are some example codes that you can already run in Jupyter Notebook. Below, I will write down the core knowledge points (how to build a prompt and…
阅读更多...
CSS基础学习--4 创建式样

CSS基础学习--4 创建式样

一、插入样式表的几种方法&#xff1f; 外部样式表内部样式表内联样式 二、外部样式表 使用前提&#xff1a;当样式需要应用于很多页面时&#xff0c;外部样式表将是理想的选择。 在使用外部样式表的情况下&#xff0c;你可以通过改变一个文件来改变整个站点的外观。每个页…
阅读更多...
Ognl使用总结

Ognl使用总结

目录 一、简介二、快速入门三、详细使用3.0 Ognl操作3.1 基本数据类型3.2 对象类型3.3 List集合3.4 Set集合3.5 Map集合3.6 数组3.7 静态调用3.8 算术运算3.9 逻辑运算3.10 同时执行多个表达式3.11 位运算 一、简介 OGNL&#xff08;Object-Graph Navigation Language的简称&a…
阅读更多...
开始使用chat-gpt4

开始使用chat-gpt4

目录 一、说明 二、安装步骤 三、测试效果咋样 &#xff08;1&#xff09;写代码能力 &#xff08;2&#xff09;回答问题能力 &#xff08;3&#xff09;写作能力 一、说明 参考&#xff08;非常感谢这位博主的分享&#xff09;&#xff1a;http://t.csdn.cn/qypw9 注意&…
阅读更多...
FTP服务器项目

FTP服务器项目

文章目录 1. 项目简介2. FTP协议和用到指令说明2.1 FTP协议详解2.2 指令说明 3. FTP项目的类图分析3.1 UML3.2 工厂类XFtpFactoryXFtpFactory.hXFtpFactory.cpp 2.2 XFtpTaskXFtpTask.hXFtpTask.cpp 2.3 XFtpServerCMDXFtpServerCMD.hXFtpServerCMD.cpp 4. 运行演示FileZilla的…
阅读更多...
数字逻辑期末必刷卷(基础卷)

数字逻辑期末必刷卷(基础卷)

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 &#x1f4a1;一、填空题&#xff08;每空1分&#xff0c;共20分&#xff09;&#x1f4a1;二、单项选择题&#xff08;每小题2分&#xff0c;共20分&#xff09;&a…
阅读更多...
第七章 Linux实际操作——组管理和权限管理

第七章 Linux实际操作——组管理和权限管理

第七章 Linux实际操作——组管理和权限管理 7.1 Linux组基本介绍7.2 文件、目录 所有者7.2.1 查看文件的所有者7.2.2 修改文件所有者 7.3 组的创建7.3.1 基本指令7.3.2 应用实例 7.4 文件、目录所在组7.4.1 查看文件、目录所在组7.4.2 修改文件、目录所在组 7.5 其他组7.6 权限…
阅读更多...
观澜南林輋旧改回迁房--周边巨量旧改，未来区政府核心商圈。

观澜南林輋旧改回迁房--周边巨量旧改，未来区政府核心商圈。

项目亮点 观澜福城街道办旧改最集中的区域&#xff0c;且地铁4号的茜坑站就在门口&#xff01;未来一区域成为龙华区政府的中心地段。本项目拆迁约10万&#xff0c;主打高端商业综合体&#xff0c;项目规划27班九年一贯性学校&#xff0c;约4万多平用于建设公共设施、绿地。 …
阅读更多...
ROS学习——通信机制（服务通信）

ROS学习——通信机制（服务通信）

2.2.3 服务通信自定义srv调用A(C) Autolabor-ROS机器人入门课程《ROS理论与实践》零基础教程 068服务通信(C)3_客户端优化_Chapter2-ROS通信机制_哔哩哔哩_bilibili 一、理论模型 服务通信也是ROS中一种极其常用的通信模式&#xff0c;服务通信是基于请求响应模式的&#xf…
阅读更多...
【Java|多线程与高并发】volatile关键字和内存可见性问题

【Java|多线程与高并发】volatile关键字和内存可见性问题

文章目录 1.前言2. 编译器优化带来的内存可见性问题3. 使用volatile保证内存可见性5.volatile不能保证原子性以JMM的角度看待volatile总结 1.前言 synchronized和volatile都是Java多线程中很重要的关键字&#xff0c;但它们的作用和使用场景有所不同。 synchronized关键字可以…
阅读更多...
Linux之文件打包和解压缩

Linux之文件打包和解压缩

任务描述 有时&#xff0c;我们会在Linux系统中将多个文件打包成一个单独的文件&#xff0c;通过本关的学习&#xff0c;我们将学会如何在Linux系统中将多个文件/目录打包生成一个文件。 本关任务&#xff1a;使用tar命令完成文件和目录的打包操作。 相关知识 tar&#xff…
阅读更多...
验证断言（立即断言并行断言）

验证断言（立即断言并行断言）

目录 1.何为断言 2.断言的作用&#xff1a; 3.断言的种类 3.1立即断言 3.2并发断言 4.断言层次结构 4.1 sequence 序列 4.2 property 序列 5.sequence和property的异同 6.补充知识点&#xff08;assert/cover/assume&#xff09; 7.写在后边 1.何为断言 断言主要…
阅读更多...
网络知识点之-FTP协议

网络知识点之-FTP协议

FTP协议指文件传输协议&#xff08;File Transfer Protocol&#xff0c;FTP&#xff09;&#xff0c;是用于在网络上进行文件传输的一套标准协议&#xff0c;它工作在 OSI 模型的第七层&#xff0c; TCP 模型的第四层&#xff0c; 即应用层&#xff0c; 使用 TCP 传输而不是 UD…
阅读更多...
第一节 初识C语言

第一节 初识C语言

第一节 初识C语言 目录 一&#xff0e; 什么是C语言二&#xff0e; 第一个C语言程序三&#xff0e; 数据类型四&#xff0e; 变量与常量五&#xff0e; 未完待续 本章重点&#xff1a; 什么是C语言第一个C语言程序数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组…
阅读更多...
【LeetCode】每日一题 -- 1171. 从链表中删去总和值为零的连续节点 -- Java Version

【LeetCode】每日一题 -- 1171. 从链表中删去总和值为零的连续节点 -- Java Version

题目链接&#xff1a;https://leetcode.cn/problems/remove-zero-sum-consecutive-nodes-from-linked-list/ 1. 题解&#xff08;1171. 从链表中删去总和值为零的连续节点&#xff09; 2021年字节二面真题 1.1 暴力解法&#xff1a;穷举 时间复杂度 O(n2)&#xff0c;空间复杂…
阅读更多...
Python系列之面向对象编程

Python系列之面向对象编程

目录 一、面向对象编程 1.1 面向对象三大特征 1.2 什么是对象 二、类(class)和实例(instance) 2.1 类的构成 2.2 创建类 2.3 创建实例对象和访问属性 2.4 Python内置类属性 2.5 类属性与方法 三、类的继承 3.1 方法重写 四、多态 一、面向对象编程 1.1 面向对象三大…
阅读更多...
抖音短视频矩阵系统-源码-系统搭建

抖音短视频矩阵系统-源码-系统搭建

目录 1. 短视频AI智能创作 2. 托管式账号管理: 3. 数据分析 4. 智能营销获客 开发流程 抖音账号矩阵系统开发&#xff0c;抖音账号矩阵系统源码搭建&#xff0c;抖音账号技术系统源码部署 抖音矩阵系统专注于为短视频私域运营达人或企业提供一站式赋能服务平台。具体包括智…
阅读更多...
小议CSDN周赛57期 - 凑数

小议CSDN周赛57期 - 凑数

本期周赛几乎忘记参加&#xff0c;在最后几分钟的时候上来看了看。那些选择判断一通乱选&#xff0c;填空题也已经被吐槽得差不多了&#xff0c;这里不多说&#xff0c;只说我对第一道编程题的看法&#xff08;吐槽&#xff09;。因为 C 站的机制是&#xff0c;即使它错了&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023