Spring 更简单的读取和存储对象

news2024/9/19 15:19:31

✏️作者：银河罐头
📋系列专栏：JavaEE

🌲“种一棵树最好的时间是十年前，其次是现在”

前面介绍了通过配置文件的方式来存储 Bean 对象，那么有没有更简单的方式去存储 Bean 对象？

有以下 2 种方式：

1.类注解(五大类注解) : @Controller、@Service、@Repository、@Component、@Configuration.

2.方法注解：@Bean

存储 Bean 对象

前置工作：配置扫描路径

image-20230501110341142

五大类注解

@Controller

控制器，验证用户请求的数据是否正确。

@Controller  //将当前类存储到 spring 中
public class StudentController {
    public void sayHi(){
        System.out.println("do studentController sayHi()");
    }
}

public class App {
    public static void main(String[] args) {
        //1.得到 spring 对象
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("spring-config.xml");
        //2.得到 Bean 对象
        StudentController studentController =
                applicationContext.getBean("studentController",StudentController.class);
        //3.使用 Bean
        studentController.sayHi();
    }
}

image-20230501111633465

image-20230501111655547

感觉小驼峰才行。

再看一个例子。

@Controller
public class SController {
    public void sayHi(){
        System.out.println("do SController sayHi");
    }
}

public class App {
    public static void main(String[] args) {
        //1.得到 spring 对象
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("spring-config.xml");

        SController sController = applicationContext.getBean("sController",SController.class);
        sController.sayHi();
    }
}

image-20230501112114823

image-20230501112142141

当类名的首字母是大写，第二个字母是小写时，Bean 的名称使用首字母小写，如：StudentController;

(特例)当类名的首字母和第二个字母都是大写时，Bean 的名称使用原类名。如：SController.

Spring 设计理念：约定大于配置。

@Service

服务，编排和调度具体执行方法。

@Service
public class StudentController2 {
    public void sayHi(){
        System.out.println("do studentController2 sayHi()");
    }
}

public class App {
    public static void main(String[] args) {
        //1.得到 spring 对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        StudentController2 studentController2 =
                context.getBean("studentController2",StudentController2.class);
        studentController2.sayHi();
    }
}

image-20230501113511071

@Repository

持久层，和数据库交互。

@Repository
public class StudentController3 {
    public void sayHi(){
        System.out.println("do studentController3 sayHi()");
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        StudentController3 studentController3 =
                context.getBean("studentController3",StudentController3.class);
        studentController3.sayHi();
    }
}

image-20230501114604350

@Component

组件

@Component
public class StudentController4 {
    public void sayHi(){
        System.out.println("do studentController4 sayHi()");
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        StudentController4 studentController4 =
                context.getBean("studentController4", StudentController4.class);
        studentController4.sayHi();
    }
}

image-20230501114804787

@Configuration

配置项。

@Configuration
public class StudentController5 {
    public void sayHi(){
        System.out.println("do studentController5 sayHi()");
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        StudentController5 studentController5 =
                context.getBean("studentController5", StudentController5.class);
        studentController5.sayHi();
    }
}

image-20230501115115063

问题

bean 标签是否可以和 component-scan 一起使用？

image-20230501115459640

答案是可以。

public class UserService {
    public void sayHi(){
        System.out.println("do userService sayHi()");
    }
}

<content:component-scan base-package="com.java.demo"></content:component-scan>

<bean id="userService" class="com.java.service.UserService"></bean>

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        UserService userService =
                context.getBean("userService",UserService.class);
        userService.sayHi();
    }
}

image-20230501135211507

五大类注解是否可以加到非 base-package 里？

image-20230501135413407

@Service
public class StudentService {
    public void sayHi(){
        System.out.println("do studentService sayHi()");
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        StudentService studentService =
                context.getBean("studentService",StudentService.class);
        studentService.sayHi();
    }
}

image-20230501135726143

答案是: 不可以!!!

在 component-scan 包里但不加五大类注解是否能读取到？

答案是不可以!!!

//@Controller  
public class StudentController {
    public void sayHi(){
        System.out.println("do studentController sayHi()");
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        
        StudentController studentController
                = context.getBean("studentController",StudentController.class);
        studentController.sayHi();
    }
}

image-20230501140245803

component-scan 子包的类能读取到吗？

image-20230501141034926

package com.java.demo.controller.bbb;

import org.springframework.stereotype.Controller;

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

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        UserController userController =
                context.getBean("userController",UserController.class);
        userController.sayHi();
    }
}

image-20230501140857565

component-scan 下的所有子包里的类加了五大类注解都能存储到 spring 中。

不同包的同名类是否能正确读取？

package com.java.demo;

import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    public void sayHi(){
        System.out.println("com.java.demo -> do userController sayHi()");
    }
}

package com.java.demo.controller.bbb;

import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    public void sayHi(){
        System.out.println("com.java.demo.controller.bbb -> do userController sayHi()");
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        UserController userController =
                context.getBean("userController",UserController.class);
        userController.sayHi();
    }
}

image-20230501142043096

答案是不可以!!!

可以把其中一个重命名来解决冲突。

package com.java.demo;

import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    public void sayHi(){
        System.out.println("com.java.demo -> do userController sayHi()");
    }
}

package com.java.demo.controller.bbb;

import org.springframework.stereotype.Controller;

@Controller(value = "UserController2")
public class UserController {
    public void sayHi(){
        System.out.println("com.java.demo.controller.bbb -> do userController sayHi()");
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        UserController userController =
                context.getBean("userController",UserController.class);
        userController.sayHi();

        com.java.demo.controller.bbb.UserController userController2 =
                context.getBean("UserController2",
                        com.java.demo.controller.bbb.UserController.class);
        userController2.sayHi();
    }
}

image-20230501143217410

五大类注解之间有什么关系？

image-20230501145422305

Controller 是 基于 Component 实现的.

image-20230501145538682

Service 是基于 Component 实现的.

image-20230501145621332

Repository 是基于 Component 实现的.

image-20230501145756297

Configuration 是基于 Component 实现的.

@Controller / @Service / @Repository / @Configuration 都是 @Component 的"子类"。

为什么要这么多类注解？

image-20230501151002059

JavaEE 标准分层，至少是三层：1.控制层 2.服务层 3.数据持久层

需要这么多注解的作用就是让人看到注解之后能知道这个类的作用。

下图出自《阿里巴巴 Java 开发手册-嵩山版》应用分层：

image-20230501153007405

Bean 命名规则

image-20230501160441931

image-20230501160459836

image-20230501160728383

image-20230501163154576

而 decapitalize 是来自于 jdk.

Bean 命名规则：

默认情况下是首字母小写；特殊情况如果类名首字母和第二个字母都是大写，Bean 名称为原类名。

下面测试一下 Bean 的命名规则：

import java.beans.Introspector;
public class BeanNameTest {
    public static void main(String[] args) {
        String className = "UserClass";
        String className2 = "UClass";
        System.out.println("UserClass -> " + Introspector.decapitalize(className));
        System.out.println("UClass -> " + Introspector.decapitalize(className2));
    }
}

image-20230501163505361

方法注解@Bean

要求这个方法必须有返回值。

@Bean 将方法返回的对象存到 spring 中。

方法注解要配合类注解使用。

实体类命名规则：image-20230501212640779

package com.java.demo.entity;

public class User {
    private Integer uid;
    private String username;
    private String password;
    private Integer age;

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

package com.java.demo.component;
import com.java.demo.entity.User;
import org.springframework.context.annotation.Bean;

public class UserBeans {
    @Bean
    public User user1(){
        User user = new User();
        user.setUid(1);
        user.setUsername("张三");
        user.setPassword("123456");
        user.setAge(18);
        return user;
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        User user = context.getBean("user", User.class);
        System.out.println(user.getUsername());
    }
}

如果按照之前五大类注解 Bean 的名称命名规则去取 User , 结果报错：

image-20230502101233532

造成报错的原因有 2 个：

1.@Bean 的命名规则和五大类注解的命名规则不同，Bean 的名称 = 方法名

2.@Bean 必须要配合五大类注解使用.(Spring 为了提升性能)

image-20230502102239085

image-20230502102251221

重命名 Bean

image-20230502103316130

image-20230502103348784

image-20230502103432426

image-20230502103458988

image-20230502103533132

@Bean 重命名用 “name” 或 “value” 都行。并且重命名可以起多个名字(String[])。

问题：@Bean 重命名之后，用 方法名还能成功获取到 对象吗？

image-20230502103954471

image-20230502104039651

答案是不行!!!

问题：如果有多个 User 对象存在 Spring 当中，还能成功获取到吗？

@Component
public class UserBeans {
    @Bean(name = {"user1","u1"})
    public User getuserbyid(){
        User user = new User();
        user.setUid(1);
        user.setUsername("张三");
        user.setPassword("123456");
        user.setAge(18);
        return user;
    }

    @Bean
    public User getuserbyname(){
        User user = new User();
        user.setUid(2);
        user.setUsername("李四");
        user.setPassword("654321");
        user.setAge(20);
        return user;
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        User user = context.getBean("getuserbyname", User.class);
        System.out.println(user.getUsername());
    }
}

image-20230502104748899

答案是可以。

Spring 容器允许将同一个类型的多个对象存到容器中。

问题：如果在不同类中有同名的方法，会出现什么情况？

image-20230502105038868

@Component
public class UserBeans2 {
    @Bean
    public User getuserbyname(){
        User user = new User();
        user.setUid(2);
        user.setUsername("王五");
        user.setPassword("654321");
        user.setAge(20);
        return user;
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        User user = context.getBean("getuserbyname", User.class);
        System.out.println(user.getUsername());
    }
}

image-20230502105111891

@Component
@Order(20)
public class UserBeans {

@Component
@Order(10)
public class UserBeans2 {

如果在 类前面加个 @Order 注解，就会设置顺序。@Order可以控制注入的顺序。@Order 值越大，优先级越大。

image-20230502105542917

获取 Bean 对象(对象装配)

更加简单的从 spring 容器中读取 Bean.

属性注入

package com.java.demo.controller;
import com.java.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {

    @Autowired
    private UserService userService;
    
    public void sayHi(){
        System.out.println("com.java.demo -> do userController sayHi()");
        userService.sayHi();
    }
}

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

image-20230504114110264

运行报错。因为 main 方法是 static , 执行早于 spring. 所以这样是无法从 spring 中获取到 Bean.

image-20230504132114829

属性注入：

优点：简单。

缺点：

1.不能实现 final 属性的注入。

image-20230504132615493

2.兼容不好，只适用于 IoC 容器.

3.因为使用简单，所以违背单一设计原则的概率更大。

setter 注入

package com.java.demo.controller;
import com.java.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
//    1.属性注入
//    @Autowired
//    private UserService userService;

    //2.Setter 注入
    private UserService userService;

    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void sayHi(){
        System.out.println("com.java.demo -> do userController sayHi()");
        userService.sayHi();
    }
}

image-20230504133712241

Setter注入

优点：

1.符合单一设计原则，一个 Setter 只针对一个对象。

缺点：

1.不能注入不可变对象(final 修饰的对象)

image-20230504134733895

2.注入的对象可以被修改。

因为 setUserService() 方法它是支持被反复调用的。

构造方法注入

spring 官方推荐的注入方式。

package com.java.demo.controller;
import com.java.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    //3.构造方法注入
    private UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void sayHi(){
        System.out.println("com.java.demo -> do userController sayHi()");
        userService.sayHi();
    }
}

image-20230504135621998

构造方法注入有个特别的地方在于：它不加 @Autowired 注解也能运行成功！

image-20230504135814215

但是，如果一个类里有多个构造方法的时候，@Autowired 注解不能省略。

优点：

1.能注入不可变对象(final 修饰的对象)

image-20230504140921330

问题来了：为什么构造方法能够诸如一个不可变对象，而属性注入和 setter 注入不行？

final 修饰的对象，要么是直接赋值；要么是在构造方法中被赋值。

	//1.
	private final Integer num;
    public App2(Integer num) {
        this.num = num;
    }
	//2.
    private final Integer num2 = 10;

2.注入对象不会被修改，因为构造方法只能执行一次。

3.构造方法注入能够保证注入对象已经完全初始化。

4.兼容性更好。

@Resource：另⼀种注入关键字

@Autowired 来自 spring,

@Resource 来自 JDK.

image-20230504144710148

image-20230504144812932

image-20230504145235528

@Resource 支持 属性注入和setter 注入，但是不支持 构造方法注入。

@Autowired 和 @Resource 的区别：

1.@Autowired 来自 spring, @Resource 来自 JDK.

2.@Autowired 支持 3 种注入方式，而 @Resource 只支持 2 种注入方式。

3.@Resource 支持更多的参数设置，而@Autowired 只支持 1 种

image-20230504151240975

image-20230504151334222

如果一个类的多个对象放到 spring 当中，此时使用 @Autowired 就不行，因为 @Autowired 不支持重命名。而

@Resource 可以。

下面通过代码来验证关于参数这一点，如果把一个类的多个对象存到 spring 当中，去取 Bean 用@Autowired 会报错。

@Component
@Order(1)
public class UserBeans {
    @Bean(name = {"user1","u1"})
    public User getuserbyid(){
        User user = new User();
        user.setUid(1);
        user.setUsername("张三");
        user.setPassword("123456");
        user.setAge(18);
        return user;
    }
    @Bean
    public User getuserbyname(){
        User user = new User();
        user.setUid(2);
        user.setUsername("李四");
        user.setPassword("654321");
        user.setAge(20);
        return user;
    }
}

@Component
@Order(10)
public class UserBeans2 {
    @Bean
    public User getuserbyname(){
        User user = new User();
        user.setUid(2);
        user.setUsername("王五");
        user.setPassword("654321");
        user.setAge(20);
        return user;
    }
}

前面写过的 User 类的多个对象存到 spring 当中。

@Controller
public class UserController2 {

    @Autowired
    private User user;

    public void sayHi(){
        System.out.println("com.java.demo -> do userController2 sayHi()");
        System.out.println(user.getUsername());
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        UserController2 userController2 =
                context.getBean("userController2",UserController2.class);
        userController2.sayHi();
    }
}

image-20230504155326111

在 spring 容器中查找 Bean，有 2 种方式：1.根据类查找，2.根据名称查找。

@Autowired 会先根据类型(byType)查找，再根据名称(byName)查找。如果这样查了之后还找不到一个唯一的 Bean 就会报错。

而@Resource 相反，它是先根据名称去查，然后再根据类型去查。

这个查找顺序是 @Autowired 和 @Resource 的第四个区别。

image-20230504161050749

上面User 那个例子 把 @Autowired 改成 @Resource 还是会报错，原因还是 找不到 唯一的 Bean.

不过，@Resource 可以设置 name 参数，起别名。

image-20230504161425449

那如果我非要用 @Autowired 去取呢？

image-20230504162148859

可以多加一个 @Qualifier 起到一个筛选的作用。

小练习

在 Spring 项目中，通过 main 方法获取到 Controller 类，调用 Controller 里面通过注⼊的⽅式调⽤ Service 类，Service 再通过注入的方式获取到 Repository 类，Repository 类里面有⼀个⽅法构建⼀ 个 User 对象，返回给 main 方法。Repository 无需连接数据库，使用伪代码即可。

import com.java.demo.controller.MyController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyApp {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        MyController myController = context.getBean("myController", MyController.class);
        myController.sayHi();
    }
}

package com.java.demo.controller;

import com.java.demo.service.MyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class MyController {
    @Autowired
    private MyService myService;

    public void sayHi(){
        System.out.println("do MyController sayHi()");
        myService.sayHi();
    }
}

package com.java.demo.service;
import com.java.demo.repository.MyRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    @Autowired
    private MyRepository myRepository;

    public void sayHi(){
        System.out.println("do MyService sayHi()");
        System.out.println(myRepository.getUser().getUsername());
    }
}

package com.java.demo.repository;
import com.java.demo.entity.User;
import org.springframework.stereotype.Repository;

@Repository
public class MyRepository {
    public User getUser(){
        User user = new User();
        user.setUsername("周八");
        return user;
    }
}

image-20230504164217180

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

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

相关文章

【论文】LearningDepth from Single Monocular Images

【论文】LearningDepth from Single Monocular Images

2005 NIPS 文章目录 特征提取卷积核的使用Multiscale 多尺度提取特征特征的相对深度 模型结论特征提取数据集导致的error 文章使用了Markov 随机场(Markov Random Fields, MRF) 从单图像上直接估计出图像的深度信息。 与RGBD输入数据不同的是&#xff0c;文章中采用了YCbCr数据…
阅读更多...
知识点总结-DAY1

知识点总结-DAY1

1. 请解释OSI模型中每一层的作用 应用层&#xff1a;为用户提供服务&#xff0c;处理应用程序之间交换的数据。 表示层&#xff1a;处理数据在网络上的表示形式&#xff0c;如加密和解密、压缩和解压缩等。 会话层&#xff1a;建立、维护和终止两个节点之间的会话&#xff0c…
阅读更多...
安全防御 --- IPSec理论

安全防御 --- IPSec理论

IPSec 1、概述&#xff1a; 是IETF&#xff08;Internet Engineering Task Force&#xff09;制定的一组开放的网络安全协议&#xff0c;在IP层通过数据来源认证、数据加密、数据完整性和抗重放功能来保证通信双方Internet上传输数据的安全性。 IPSec安全服务 机密性完整性…
阅读更多...
雨季时，骑行经过泥泞路段该怎么办？

雨季时，骑行经过泥泞路段该怎么办？

泥泞路段骑行是一项需要技巧和勇气的挑战。在泥泞路段骑行&#xff0c;骑友又叫玩泥巴&#xff0c;不仅需要良好的车技和身体素质&#xff0c;还需要有足够的经验和判断力&#xff0c;以应对各种突发情况。下面&#xff0c;将从多个角度介绍泥泞路段骑行的挑战和技巧&#xff0…
阅读更多...
宏观经济笔记--社会消费品零售总额

宏观经济笔记--社会消费品零售总额

我们讨论了GDP的三个分项&#xff1a;投资、消费、净出口。投资我们前面已经介绍了&#xff0c;消费这一个分项我们还一直没有讨论。消费最重要的数据是每个月月中统计局公布的社会消费品零售总额。 一般的论调中&#xff0c;认为消费是三个GDP驱动项中最健康的一项&#xff0…
阅读更多...
2023-5-4-Lua语言学习

2023-5-4-Lua语言学习

&#x1f37f;*★,*:.☆(&#xffe3;▽&#xffe3;)/$:*.★* &#x1f37f; &#x1f4a5;&#x1f4a5;&#x1f4a5;欢迎来到&#x1f91e;汤姆&#x1f91e;的csdn博文&#x1f4a5;&#x1f4a5;&#x1f4a5; &#x1f49f;&#x1f49f;喜欢的朋友可以关注一下&#xf…
阅读更多...
openQA----基于openQA新增指定版本的openSUSE的iso镜像进行测试

openQA----基于openQA新增指定版本的openSUSE的iso镜像进行测试

【原文链接】openQA----基于openQA新增指定版本的openSUSE的iso镜像进行测试 &#xff08;1&#xff09;执行如下命令下载openSUSE的测试脚本&#xff0c;它会从openSUSE的测试脚本github地址 /usr/share/openqa/script/fetchneedles&#xff08;2&#xff09;然后执行如下命…
阅读更多...
在 SourceTree 中使用 rebase （win10）

在 SourceTree 中使用 rebase （win10）

原始状态 创建两个分支 dev1 dev2, 并且推送到远端 切换到dev1 做一些修改并提交dev1-1&#xff0c;注意不要推送到到远端 切换到master分支&#xff0c;拉取最新的代码 切换到dev1 分支&#xff0c;进行变基操作&#xff0c;右击master分支 推送dev1分支到远端 切换到master分…
阅读更多...
如何快速获取已发表学术论文的期刊封面及目录(caj格式下载和caj转pdf)

如何快速获取已发表学术论文的期刊封面及目录(caj格式下载和caj转pdf)

目录 1 下载caj格式的封面和目录 2 CAJ格式的封面和目录转PDF格式 在进行职称评审或成果申报时&#xff0c;一般要求提交你发表的成果所在的期刊的当期封面和目录。本文就手把手带带你制作一个期刊目录。 重要提示&#xff1a;下载期刊封面和目录需要你有知网账号&#xff0…
阅读更多...
iOS 17预计开放侧载，游戏安全对抗将迎来新高度

iOS 17预计开放侧载，游戏安全对抗将迎来新高度

近日&#xff0c;据彭博社报道&#xff0c;iOS 17预计开放“侧载”机制。所谓的“侧载”是指&#xff1a;iPhone用户下载APP时&#xff0c;可选择不在APP store中下载&#xff0c;可在相关APP官网或者第三方应用市场进行下载。 众所周知&#xff0c;APP闭源生态是苹果公司最核…
阅读更多...
C++ 基础二

C++ 基础二

C 核心编程 1 内存分区模型 内存分区模型 代码区&#xff1a;存放函数的二级制代码&#xff0c;由操作系统进行管理的 全局区&#xff1a;存放全局变量和静态变量以及常量 栈区&#xff1a;由编译器自动分配释放&#xff0c;存放函数的参数值&#xff0c;局部变量等 堆区&…
阅读更多...
5.1 矩阵的特征值和特征向量

5.1 矩阵的特征值和特征向量

学习步骤&#xff1a; 学习特征值和特征向量的定义和性质&#xff0c;我会采取以下方法&#xff1a; 1. 学习线性代数基础知识&#xff1a;特征值和特征向量是线性代数中的重要概念&#xff0c;需要先掌握线性代数的基础知识&#xff0c;例如向量、矩阵、行列式、逆矩阵、转置…
阅读更多...
Bark：基于转换器的文本到音频模型

Bark：基于转换器的文本到音频模型

Bark是由Suno创建的一个基于转换器的文本到音频模型。Bark可以生成高度逼真的多语言语音以及其他音频&#xff0c;包括音乐、背景噪音和简单的音效。该模型还可以产生非语言交流&#xff0c;如大笑、叹息和哭泣。为了支持研究社区&#xff0c;我们正在提供对预先训练的模型检查…
阅读更多...
生物信息学中---数据集不平衡的处理方法

生物信息学中---数据集不平衡的处理方法

1.NearMiss&#xff1a; NearMiss 是 Mani 等人根据数据分布特征&#xff0c;基于 KNN 算法提出的欠采样方案&#xff0c; 对多数类样本利用随机欠采样来达到数据平衡。 根据不同数据采样的距离&#xff0c;可以分为三类&#xff1a; NearMiss-1、 NearMiss-2 和 NearMiss-3。…
阅读更多...
什么是数据库分片？

什么是数据库分片？

什么是数据库分片&#xff1f; 数据库分片是指将一个大型数据库拆分成多个小型数据库&#xff0c;每个小型数据库称为一个分片。通过这种方式&#xff0c;可以将数据库的负载分散到多个服务器上&#xff0c;从而提高数据库的性能和可伸缩性。 为什么需要数据库分片&#xff1f…
阅读更多...
从一到无穷大 #7 Database-as-a-Service租户隔离挑战与解决措施

从一到无穷大 #7 Database-as-a-Service租户隔离挑战与解决措施

文章目录 引言计算侧多租户隔离2DFQSQLVMRetro 其他隔离方法其他 引言 在云环境中租户之间的资源共享对于运营商的成本效益来说非常重要&#xff0c;但是一个主要问题是租户之间的资源隔离&#xff0c;这通常与Qos息息相关&#xff0c;从多租户的角度讲&#xff0c;安全性/性能…
阅读更多...
ChatGPT 不好用？那你看下这份 Prompt 工程指南

ChatGPT 不好用？那你看下这份 Prompt 工程指南

作为大型语言模型接口&#xff0c;ChatGPT 生成的响应令人刮目相看&#xff0c;然而&#xff0c;解锁其真正威力的关键还是在于提示工程。 在本文中&#xff0c;我们将揭示制作提示的专家级技巧&#xff0c;以生成更准确、更有意义的响应。无论你使用 ChatGPT 是为了服务客户、…
阅读更多...
用格林童话教你1分钟清晰JS加密

用格林童话教你1分钟清晰JS加密

在许多格林童话中&#xff0c;我们可以看到许多隐藏的玄机和谜题&#xff0c;就像JavaScript代码一样。为了保护您的代码安全&#xff0c;我们可以使用JavaScript混淆加密技术来隐藏代码中的逻辑和关键信息。在本文中&#xff0c;我们将以“灰姑娘”为例&#xff0c;介绍如何使…
阅读更多...
【视频解读】动手学深度学习V2_00预告

【视频解读】动手学深度学习V2_00预告

00预告 【动手学深度学习V2】 深度学习是人工智能最热的领域&#xff0c;在过去十年&#xff0c;人工智能的主要突破都来自于深度学习。 深度学习的核心是神经网络&#xff0c;它与人工智能的其他领域不一样的是&#xff0c;神经网络是一个非常灵活的框架&#xff0c;它允许我…
阅读更多...
typescript is类型谓词

typescript is类型谓词

一、类型谓词是干嘛的&#xff1f; 类型谓词可以有效的帮助我们根据条件缩小类型范围&#xff08;narrowing&#xff09;。它与 typeof、instanceof、in类似。但是不同的是typeof、instanceof、in关键字在js中已经是存在的&#xff0c;在ts中使用它们&#xff0c;进行类型收缩…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023