Spring IoCDI（2）—IoC详解

news2024/11/14 17:27:36

目录

一、IoC详解

1、Bean的存储

（1）@Controller（控制器存储）

获取bean对象的其他方式

Bean 命名约定

（2）@Service（服务存储）

（3）@Repository（仓库存储）

（4）@Component（组件存储）

（5）@Configuration（配置存储）

2、为什么要这么多类注解？

类注解之间的关系：

3、方法注解 @Bean

（1）方法注解要配合类注解使用

（2）定义多个对象

（3）重命名 Bean

4、扫描路径

一、IoC详解

        IoC控制反转，就是将对象的控制权交给Spring的IoC容器，由IoC容器创建及管理对象；也就是bean的存储。

        共有两类注解类型可以实现：1、类注解：@Controller、@Service、@Repository、@Component、@Configuration。2、方法注解：@Bean。

1、Bean的存储

（1）@Controller（控制器存储）

        使用@Controller注解，存储bean的代码如下：

@Controller
public class UserController {
    public void sayHi() {
        System.out.println("hi, UserController");
    }
}

        这个对象加了@Controller注解，就把这个对象放在Spring容器中了，下面是从Spring容器获取对象，代码如下：

@SpringBootApplication
public class SpringIoC2Application {

    public static void main(String[] args) {
        //获取Spring的上下文
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring的上下文中获取对象
        UserController bean = (UserController)context.getBean(UserController.class);
        bean.sayHi();
    }
}

        ApplicantContent 翻译过来就是：Spring 上下文。因为对象交给Spring管理了，所以获取对象要从Spring中获取，那么就得先得到Spring的上下文。

        关于上下文的概念：在计算机领域，上下文这个概念，在线程那已经了解过了，比如应用进行线程切换的时候，切换前都会把线程的状态信息暂时存储起来，这里的上下文就包括了当前线程的信息，等下次该线程又得到CPU时间的时候，从上下文中拿到线程上次运行的信息。

        这里的上下文，就是当前的运行环境，也可以看做是一个容器，容器里存了很多内容，这些内容是当前运行的环境。

        观察运行结果，发现成功从Spring中获取了Controller 对象，并执行Controller的sayHi方法，如图：

        如果把UserController类上面的注解@Controller去掉，就会报错，如图：

        报错信息：找不到类型是com.example.springioc2.controller.UserController的bean；因为没加这个注解，自然也就没声明把这个类交给Spring管理，Spring也就找不到该类的bean了。

获取bean对象的其他方式

        上述代码是根据类型来查找对象的，如果Spring容器中，同一个类型存在多个bean的话，要怎么获取？ApplicationContext也提供了其他获取bean的方式，ApplicationContext获取bean对象的功能，是父类BeanFactory提供的功能。如下代码：

public interface BeanFactory {
    //以上省略...
    // 1. 根据bean名称获取bean
    Object getBean(String var1) throws BeansException;
    // 2. 根据bean名称和类型获取bean
    <T> T getBean(String var1, Class<T> var2) throws BeansException;
    // 3. 按bean名称和构造函数参数动态创建bean,只适⽤于具有原型(prototype)作⽤域的bean
    Object getBean(String var1, Object... var2) throws BeansException;
    // 4. 根据类型获取bean
    <T> T getBean(Class<T> var1) throws BeansException;
    // 5. 按bean类型和构造函数参数动态创建bean, 只适⽤于具有原型(prototype)作⽤域的bean
    <T> T getBean(Class<T> var1, Object... var2) throws BeansException;
    //以下省略...
}

        最常用的是1、2、4种，这三种方式（根据bean名称获取bean、根据bean类型和名称获取bean、根据bean类型获取bean），获取到的bean是一样的。

        其中1、2种都涉及到根据名称来获取对象，那么bean的名称是什么呢？

Spring bean 是Spring框架在运行时管理的对象，Spring会给管理的对象起一个名字。

比如学校管理学生，会给每个学生分配一个学号，根据学号，就可以找到对应的学生。

Spring也是如此，给每个对象都起一个名字，根据Bean的名称（BeanId）就可以获取到对应的对象。

Bean 命名约定

官方文档：Bean Overview :: Spring Framework

        程序开发人员不需要为bean指定名称（BeanId），如果没有显示的提供名称（BeanId），Spring容器将为该bean生成唯一的名称。

        命名约定：使用Java标准约定作为实例字段名。也就是bean名称以小写字母开头，然后使用驼峰式大小写。例子如下：

类名：UserController，Bean的名称为：userController

类名：AccountManager，Bean的名称为：accountManager

类名：AccountService，Bean的名称为：accountService

        也有一些特殊情况，当多个字符并且第一个字符和第二个字符都是大写时，将保留原始大小写。这些规则与java.beans.Introspector.decapitalize（Spring在这里使用的）定义的规则相同。例子如下：

类名：UController，Bean的名称为：UController

类名：AManager，Bean的名称为：AManager

        根据这个命名规则，我们来获取Bean，代码如下：

@SpringBootApplication
public class SpringIoC2Application {

    public static void main(String[] args) {
        //获取Spring的上下文
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring的上下文中获取对象
        //根据bean类型，从Spring上下文中获取对象
        UserController userController1 = (UserController)context.getBean(UserController.class);
        //根据bean名称，从Spring上下文获取对象
        UserController userController2 = (UserController)context.getBean("userController");
        //根据bean名称+类型，从Spring上下文获取对象
        UserController userController3 = (UserController) context.getBean("userController", UserController.class);

        System.out.println(userController1);
        System.out.println(userController2);
        System.out.println(userController3);
    }
}

        运行结果如下图：

        地址都是一样的，说明对象是同一个。

ApplicationContext 和 BeanFactory （常见面试题）

1、从继承关系和功能方面来说：Spring容器有两个顶级的接口：BeanFactory 和 ApplicationContext。其中BeanFactory提供了基础的访问容器的能力，而 ApplicationContext 属于 BeanFactory 的子类，它除了继承 BeanFactory 的所有功能外，它还有自己独特的特性，还添加了对国际化支持、资源访问支持、以及事件传播等方面支持。

2、从性能方面来说：ApplicationContext是一次性加载并初始化所有Bean对象（提前加载），而 BeanFactory 是需要哪个对象了，才去加载那个对象（懒加载），因此更轻量。

（2）@Service（服务存储）

        使用@Service存储bean的代码如下：

@Service
public class UserService {
    public void doService() {
        System.out.println("do Service...");
    }
}

        读取bean的代码：

@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring中获取UserService对象
        UserService userService = context.getBean(UserService.class);
        //使用对象
        userService.doService();
    }
}

        执行结果如下：

        

        把注解@Service删掉，会报错，如图：

        和去掉@Controller注解一样的报错原因一样，找不到bean。

（3）@Repository（仓库存储）

        使用@Repository存储bean代码如下：

@Repository
public class UserRepository {
    public void doRepository() {
        System.out.println("do Repository...");
    }
}

        读取bean的代码：

@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring中获取UserRepository对象
        UserRepository userRepository = context.getBean(UserRepository.class);
        //使用对象
        userRepository.doRepository();
    }
}

        运行结果：

        同样把注解@Repository去掉，会报错，如图：

        原因和上面的一样。

（4）@Component（组件存储）

        使用@Component存储bean的代码：

@Component
public class UserComponent {
    public void doComponent() {
        System.out.println("do Component...");
    }
}

        读取bean的代码：

@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring中获取UserComponent对象
        UserComponent userComponent = context.getBean(UserComponent.class);
        //使用对象
        userComponent.doComponent();
    }
}

        执行结果：

        如果把注释@Component去掉，报错和上面的一样，如图：

（5）@Configuration（配置存储）

        使用@Configuration存储bean的代码如下：

@Configuration
public class UserConfiguration {
    public void doConfiguration() {
        System.out.println("do Configuration...");
    }
}

        读取bean的代码：

@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring中获取UserComponent对象
        UserConfiguration userConfiguration = context.getBean(UserConfiguration.class);
        //使用对象
        userConfiguration.doConfiguration();
    }
}

        执行结果如下：

        同样，把注释@Configuration去掉，会报错，原因和上面的都一样，结果如下：

2、为什么要这么多类注解？

        这个和前面的应用分层是对应的，程序员看到这些类注解后，就能直接了解当前类的用途。

@Controller：控制层，接收请求，对请求进行处理，并进行响应。

@Service：业务逻辑层，处理具体的业务逻辑。

@Repository：数据访问层，也称为持久层。负责数据访问操作。

@Configuration：配置层，处理项目中的一些配置信息。

        和三层架构的对应关系：@Controller 对应 表现层，@Service 对应 业务逻辑层，@Repository 对应 数据层。

        这里和每个省 / 市都有自己的车牌号一样，车牌号都是唯一的，我们看到车牌，就能知道车主是哪里的了 / 车的归属地，比如 粤X、京X等等。这样做的好处即可以节约号码，还有更重要的作用：标识一辆车的归属地。

        程序的应用分层，调用流程如下：

类注解之间的关系：

        查看@Controller、@Service 、@Repository、@Configuration注解的源码我们发现，它们里面都有一个@Component注解。

        这也能说明它们本身就是属于 @Component 的 “子类”。而@Component是一个元注解，也就是说可以注解其他类的注解，如 @Controller、@Service、@Repository 等等，这些注解则被称为 @Component的衍生注解。

        @Controller、@Service 和 @Repository 用于更具体的用例（分别为控制层、业务逻辑层、数据访问层），在开发过程中，如果你要在业务逻辑层使用@Component或者@Service，显然@Service是更好的选择。

        好比是杯子有喝水的（水杯），也有刷牙的（刷牙杯）等等，但我们更倾向于在日常喝水时使用水杯，洗漱时使用刷牙杯。

更多资料参考：Classpath Scanning and Managed Components :: Spring Framework

3、方法注解 @Bean

        类注解是添加到某个类上的，但是存在两个问题：1、使用外部包里的类，没办法添加类注解。2、一个类，需要多个对象，比如多个数据源。这些场景，我们就需要使用方法注解：@Bean

        以下是方法注解@Bean使用的代码：

public class BeanConfig {
    @Bean
    public UserInfo userInfo() {
        UserInfo user = new UserInfo();
        user.setId(6);
        user.setName("zhangsan");
        user.setAge(18);
        return user;
    }
}

        读取bean的代码：

@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring中获取对象
        UserInfo userInfo = context.getBean(UserInfo.class);
        //使用对象
        System.out.println(userInfo);
    }
}

        但我们发现，获取不到，程序报错了，如图：

        原因就是方法注解要搭配类注解使用，上面却没有搭配。

        为什么要搭配类注解呢？因为Spring Boot项目会引入非常多的依赖，里面的代码的方法也会有很多注解，如果都进行扫描，那就太耗时了，不如搭配类注解，Spring就知道从哪些类中扫描，大大的提高了性能。

（1）方法注解要配合类注解使用

        在Spring框架的设计中，方法注解 @Bean 要配合类注解才能将对象正常的存储到Spring容器中，代码如下：

@Component
public class BeanConfig {
    @Bean
    public UserInfo userInfo() {
        UserInfo user = new UserInfo();
        user.setId(6);
        user.setName("zhangsan");
        user.setAge(18);
        return user;
    }
}

        执行结果如下：

（2）定义多个对象

        对于同一个类，定义多个对象（多个方法使用@Bean注解）；比如多数据源的场景，类是同一个，但配置是不同的，指向不同的数据源。

@Component
public class BeanConfig {
    @Bean
    public UserInfo userInfo1() {
        UserInfo user = new UserInfo();
        user.setId(6);
        user.setName("zhangsan");
        user.setAge(18);
        return user;
    }
    
    @Bean
    public UserInfo userInfo2() {
        UserInfo user = new UserInfo();
        user.setId(7);
        user.setName("lisi");
        user.setAge(19);
        return user;
    }
}

        定义了多个对象的话，我们根据类型获取对象，获取的是哪个对象呢？代码如下：

@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring中获取对象
        UserInfo userInfo = context.getBean(UserInfo.class);
        //使用对象
        System.out.println(userInfo);
    }
}

        执行结果，可以看到，报错了：

        可以看到，报错信息显示：期望只有一个匹配，结果发现两个：userInfo1,userInfo2。从报错信息中，可以看出来，@Bean注解的bean，bean的名称就是它的方法名。

        我们现在改一下代码，根据名称来获取bean对象，代码如下：

@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring中获取对象
        UserInfo userInfo1 = (UserInfo) context.getBean("userInfo1");
        UserInfo userInfo2 = (UserInfo) context.getBean("userInfo2");
        //使用对象
        System.out.println(userInfo1);
        System.out.println(userInfo2);
    }
}

        运行结果如下：

        可以看到，@Bean可以针对同一个类，定义多个对象。

（3）重命名 Bean

        可以通过设置 name 属性，给Bean对象进行重命名操作，代码如下：

@Component
public class BeanConfig {
    @Bean(name = {"u1", "userInfo1"})
    public UserInfo userInfo1() {
        UserInfo user = new UserInfo();
        user.setId(6);
        user.setName("zhangsan");
        user.setAge(18);
        return user;
    }
}

        此时使用 u1 就可以获取到User对象了，代码如下：

@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring上下文中获取对象
        UserInfo u1 = (UserInfo)context.getBean("u1");
        //使用对象
        System.out.println(u1);
    }
}

        运行结果如下：

        使用 useInfo1 也可以获取到User对象，两个字符串都是对UserInfo的重命名，代码如下：

@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring上下文中获取对象
        UserInfo u1 = (UserInfo)context.getBean("userInfo1");
        //使用对象
        System.out.println(u1);
    }
}

        执行结果：

        其中，@Bean中的name也可以省略，代码如下：

@Component
public class BeanConfig {
    @Bean({"u1", "userInfo1"})
    public UserInfo userInfo1() {
        UserInfo user = new UserInfo();
        user.setId(6);
        user.setName("zhangsan");
        user.setAge(18);
        return user;
    }
}

        只有一个名称时，{ } 也可以省略，代码如下：

@Component
public class BeanConfig {
    @Bean("u1")
    public UserInfo userInfo1() {
        UserInfo user = new UserInfo();
        user.setId(6);
        user.setName("zhangsan");
        user.setAge(18);
        return user;
    }
}

4、扫描路径

        现在有个问题，就是不管啥类，只要搭配了五大注解或者五大注解+Bean，Spring就能启动成功吗？

        其实不然，原因就是扫描路径的问题，Spring默认只会对启动类所在的目录下进行扫描，并且扫描的是搭配了五大注解的类或者搭配五大注解+Bean的类。

        启动类：加了 @SpringBootApplication 注解的类

        现在测试一下，把启动类移动一下，此时启动类所在路径如图：

        

        试试看还能不能获取到UserService对象，UserService类的代码如下：

@Service
public class UserService {
    public void doService() {
        System.out.println("do Service...");
    }
}

        启动柜类代码如下：

@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring中获取UserService对象
        UserService userService = context.getBean(UserService.class);
        //使用对象
        userService.doService();
    }
}

        执行结果如下图：

        报错解释：没有bean的类型是UserService的。

        这里为什么没有找到bean对象呢？原因：即使使用了五大注解，或者五大注解 + @Bean注解，要想生效，还需要配置扫描路径，让Spring扫描到这些注解下的类，也就是通过 @ComponentScan 来配置。加了 @ComponentScan注解 的代码如下：

@ComponentScan({"com.example.springioc2.service"})
@SpringBootApplication
public class SpringIoC2Application {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext context = SpringApplication.run(SpringIoC2Application.class, args);
        //从Spring中获取UserService对象
        UserService userService = context.getBean(UserService.class);
        //使用对象
        userService.doService();
    }
}

        其中注解@ComponentScan的括号里面，加的是UserService类的包路径，直接复制即可，在Service类里面，如下图：

        执行结果如下：

         可以拿到bean对象了。

        其中注解@ComponentScan括号里的 { } ，可以加多个大括号，表示扫描多个路径，如图：

        那为什么之前没有配置 @ComponentScan注解 ，也可以正常启动？原因是： @ComponentScan注解 虽然没有显示配置，但是实际上已经包含在启动类声明注解@SpringBootApplication 中了。

        默认扫描的范围是：SpringBoot启动类所在包及其子包；在配置类添加 @ComponentScan注解，该注解默认会扫描该类所在的包下所有的配置类，如图：

        开发时的推荐做法：把启动类放在我们希望扫描的包的路径下，这样我们自己写的代码就都可以被扫描到了，如图：

都看到这了，点个赞再走吧，谢谢谢谢谢

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

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

相关文章

SPA模式下的多页面跳转原理及实现——jQuery Mobile为例

SPA模式下的多页面跳转原理及实现——jQuery Mobile为例

jQuery Mobile在SPA模式下的多页面跳转原理及实现案例 文章目录 jQuery Mobile在SPA模式下的多页面跳转原理及实现案例前言一、SPA的实现原理和代码分析1.实现原理说明&#xff08;1&#xff09;index.html&#xff08;2&#xff09;index.js&#xff08;3&#xff09;page2.ht…
阅读更多...
kafka日志存储

kafka日志存储

前言 kafka的主题(topic)可以对应多个分区(partition)&#xff0c;而每个分区(partition)可以有多个副本(replica)&#xff0c;我们提生产工单创建topic的时候也是要预设这些参数的。但是它究竟是如何存储的呢&#xff1f;我们在使用kafka发送消息时&#xff0c;实际表现是提交…
阅读更多...
一款开源高性能AI应用框架

一款开源高性能AI应用框架

前言 LobeChat 是一个基于 Next.js 框架构建的 AI 会话应用&#xff0c;旨在提供一个 AI 生产力平台&#xff0c;使用户能够与 AI 进行自然语言交互。 LobeChat应用架构 LobeChat 的整体架构由前端、EdgeRuntime API、Agents 市场、插件市场和独立插件组成。这些组件相互协作&a…
阅读更多...
38-1 防火墙了解

38-1 防火墙了解

一、防火墙的概念： 防火墙（Firewall)，也称防护墙，是由Check Point创立者Gil Shwed于1993年发明并引入国际互联网（US5606668 [A]1993-12-15)。它是一种位于内部网络与外部网络之间的网络安全系统，是一项信息安全的防护系统，依照特定的规则，允许或是限制传输的数据通过。…
阅读更多...
4个可将 iPhone iPad iPod 修复至正常状态的 iOS 系统恢复软件

4个可将 iPhone iPad iPod 修复至正常状态的 iOS 系统恢复软件

许多iOS用户对操作系统问题感到恐慌&#xff0c;例如iPhone卡在恢复模式、白屏死机、黑屏死机、iOS系统损坏、iTunes连接屏幕、iPhone数据丢失等。这些状态通常很无聊&#xff0c;因为您无法使用 iPhone 执行任何操作。 4个可将 iPhone iPad iPod 修复至正常状态的 iOS 系统恢复…
阅读更多...
【Unity 组件思想-预制体】

【Unity 组件思想-预制体】

【Unity 组件思想-预制体】 预制体&#xff08;Prefab&#xff09;是Unity中一种特殊的组件 特点和用途&#xff1a; 重用性&#xff1a; 预制体允许开发者创建可重复使用的自定义游戏对象。这意味着你可以创建一个预制体&#xff0c;然后在场景中多次实例化它&#xff0c;…
阅读更多...
sip转webrtc方案

sip转webrtc方案

技术选型 由于很多企业会议协议用的主要是webrtc&#xff0c;但是项目上很多时候的一些旧设备只支持sip协议&#xff0c;并不支持webrtc协议。所以sip和webrtc的相互转换就很有必要。 流媒体服务mediasoup本身并不支持sip协议。那么如何实现sip转webrtc呢&#xff1f; 根据调研…
阅读更多...
我独自升级崛起下载教程 我独自升级崛起怎么一键下载

我独自升级崛起下载教程 我独自升级崛起怎么一键下载

定于5月8日全球盛大发布的动作RPG力作《我独自升级崛起》&#xff0c;基于备受追捧的同名动画及网络漫画&#xff0c;誓为热情洋溢的游戏爱好者们呈献一场深度与广度兼具的冒险盛宴。这款游戏巧妙融合网络武侠元素&#xff0c;其创意十足的设计框架下&#xff0c;核心叙述聚焦于…
阅读更多...
[极客大挑战 2019]PHP

[极客大挑战 2019]PHP

1.通过目录扫描找到它的备份文件&#xff0c;这里的备份文件是它的源码。 2.源码当中涉及到的关键点就是魔术函数以及序列化与反序列化。 我们提交的select参数会被进行反序列化&#xff0c;我们要构造符合输出flag条件的序列化数据。 但是&#xff0c;这里要注意的就是我们提…
阅读更多...
力扣每日一题109：有序链表转换二叉搜索树

力扣每日一题109：有序链表转换二叉搜索树

题目 中等 给定一个单链表的头节点 head &#xff0c;其中的元素 按升序排序 &#xff0c;将其转换为 平衡 二叉搜索树。 示例 1: 输入: head [-10,-3,0,5,9] 输出: [0,-3,9,-10,null,5] 解释: 一个可能的答案是[0&#xff0c;-3,9&#xff0c;-10,null,5]&#xff0c;它…
阅读更多...
video标签，如何隐藏右下角三个点包含的功能？

video标签，如何隐藏右下角三个点包含的功能？

// nodownload: 不要下载 // nofullscreen: 不要全屏 // noremoteplayback: 不要远程回放 // disablePictureInPicture: 不要画中画 <videocontrols disablePictureInPicture"true"controlslist"nodownload nofullscreen noremoteplayback" > </v…
阅读更多...
Java基础教程 - 5 数组

Java基础教程 - 5 数组

更好的阅读体验&#xff1a;点这里 &#xff08; www.doubibiji.com &#xff09; 更好的阅读体验&#xff1a;点这里 &#xff08; www.doubibiji.com &#xff09; 更好的阅读体验&#xff1a;点这里 &#xff08; www.doubibiji.com &#xff09; 5 数组 前面我们保存数据…
阅读更多...
Java毕设之学院党员管理系统的设计与实现

Java毕设之学院党员管理系统的设计与实现

运行环境 环境说明: 开发语言:java 框架:springboot&#xff0c;vue JDK版本:JDK1.8 数据库:mysql5.7(推荐5.7&#xff0c;8.0也可以) 数据库工具:Navicat11 开发软件:idea/eclipse(推荐idea) Maven包:Maven3.3.9 系统实现 管理员功能实现 党员管理 管理员进入指定功能操作…
阅读更多...
AI 不仅会画画，还能造车 | 最新快讯

AI 不仅会画画，还能造车 | 最新快讯

本周的北京&#xff0c;正在上演一场深刻的变革。 汽车产业&#xff0c;这个曾经以工业制造为核心的行业&#xff0c;正迅速地被数字化浪潮所改变&#xff0c;汽车、电商、互联网、人工智能等领域的界限变得模糊。在这样的背景下&#xff0c;车企们纷纷开始打破传统&#xff0c…
阅读更多...
【AI】深度学习框架的期望与现实 机器学习编译尚未兑现其早期的一些承诺……

【AI】深度学习框架的期望与现实 机器学习编译尚未兑现其早期的一些承诺……

深度学习框架的期望与现实 机器学习编译尚未兑现其早期的一些承诺…… 来自&#xff1a;Axelera AI 资深软件工程师 Matthew Barrett 原帖是linkedin帖子&#xff1a; https://linkedin.com/posts/matthew-barrett-a49929177_i-think-its-fair-to-say-that-ml-compilation-ac…
阅读更多...
【driver2】设备读写，同步和互斥，ioctl，进程休眠，时间和延时，延缓

【driver2】设备读写，同步和互斥，ioctl，进程休眠，时间和延时，延缓

文章目录 1.实现设备读写&#xff1a;write函数中一个进程写没问题&#xff0c;两进程写&#xff1a;第一个进程运行到kzalloc时&#xff0c;第二个进程也执行了kzalloc&#xff0c;只第二个进程地址保存在c中&#xff0c;第一个进程分配内存空间地址丢失造成内存泄漏。第一个进…
阅读更多...
【Three.js基础学习】14.Galaxy Generator

【Three.js基础学习】14.Galaxy Generator

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 前言 课程知识点 1. 实现星际编辑器 2. 创建粒子 1000&#xff0c; 在随机位置 3. 创建材质 PointsMaterial 4. Points() 接收 5. 放到gui 中调试 但是会发现调整size 等 属…
阅读更多...
4.任务创建和删除的API函数

4.任务创建和删除的API函数

一、简介 二、动态创建任务函数:xTaskCreate() 此函数用于使用动态的方式创建任务&#xff0c;任务的任务控制块以及任务的栈空间所需的内存&#xff0c;均由 FreeRTOS 从 FreeRTOS 管理的堆中分配&#xff0c;若使用此函数&#xff0c;需要在 FreeRTOSConfig.h 文件 中将宏 c…
阅读更多...
5.6 qt day1

5.6 qt day1

自由创建一个登录页面 #include "mywidget.h"MyWidget::MyWidget(QWidget *parent): QWidget(parent) {//设置窗口this->setWindowTitle("");//设置窗口图标this->setWindowIcon(QIcon("C:\\Users\\14123\\Desktop\\b3119313b07eca80842876219…
阅读更多...
【go项目01_学习记录05】

【go项目01_学习记录05】

学习记录 1 依赖管理 Go Modules1.1 弃用 $GOPATH1.2 Go Modules 日常使用1.2.1 初始化生成go.mod文件1.2.2 Go Proxy代理1.2.3 go.mod文件查看1.2.4 go.sum文件查看1.2.5 indirect 含义1.2.6 go mod tidy 命令1.2.7 清空 Go Modules 缓存1.2.8 下载依赖1.2.9 所有 Go Modules …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023