JavaEE进阶学习:读取和存储对象

news2025/6/8 18:06:25

到了学习 JavaEE 这块要有一个思想,实现一个功能的时候,先考虑下有没有实现对应功能的注解.

在 Spring 中想要更简单的存储和读取对象的核心是使用注解，也就是我们接下来要学习 Spring 中的相关注解，来存储和读取 Bean 对象

1.存储 Bean 对象

之前我们存储 Bean 时，需要在 spring-config 中添加一行 bean 注册内容才行，如下图所示
在这里插入图片描述

而现在我们只需要一个注解就可以替代之前要写一行配置的要求

1.前置工作

在 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">
    <content:component-scan base-package="">
    </content:component-scan>
</beans>

base-package 写自己的内容

在这里插入图片描述

2.添加注解存储 Bean 对象

想要将对象存储在 Spring 中，有两种注解类型可以实现：

  1. 类注解：@Controller、@Service、@Repository、@Component、@Configuration

  2. 方法注解：@Bean

1.@Controller(控制器)

校验参数的合法性(类似于安检系统)

package com.wjh.demo;

import org.springframework.stereotype.Controller;

/**
 * @projectName: test-2023-11-22
 * @package: com.wjh.demo
 * @className: User
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/22 19:16
 * @version: 1.0
 */
@Controller("userinfo")
public class User {
    public void sayHello() {
        System.out.println("Hi,User!");
    }
}


import com.wjh.demo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @projectName: test-2023-11-22
 * @package: PACKAGE_NAME
 * @className: App
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/22 19:16
 * @version: 1.0
 */
public class App {
    public static void main(String[] args) {
        //1.得到容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

        //2.得到 Bean 对象
        User user = context.getBean("userinfo",User.class);

        //3.使用 Bean 对象
        user.sayHello();
    }
}

在这里插入图片描述

2.@Service(服务)

业务组装(相当于客服中心)

不做业务功能的实现

@Service
public class User {
    public void sayHello() {
        System.out.println("Hi,User!");
    }
}

3.@Repository(数据持久层)

实际的业务处理(实际办理的业务)

@Repository
public class User {
    public void sayHello() {
        System.out.println("Hi,User!");
    }
}

4.@Component(组件)

工具类层(基础的工具)

@Component
public class User {
    public void sayHello() {
        System.out.println("Hi,User!");
    }
}

5.@Configuration(配置)

配置层(配置)

@Configuration
public class User {
    public void sayHello() {
        System.out.println("Hi,User!");
    }
}

3.类注解存储 Bean 命名问题

在这里插入图片描述

默认类名首字母小写,就能获取到 Bean 对象

在这里插入图片描述
获取不到 Bean 对象

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

使用原类名,可以获取到 Bean 对象

我们可以在 Idea 中使用搜索关键字“beanName”

顺藤摸瓜，我们最后找到了 bean 对象的命名规则的方法：

在这里插入图片描述

public static String decapitalize(String name) {
 	if (name == null || name.length() == 0) {
 		return name;
 	}
 	// 如果第⼀个字⺟和第⼆个字⺟都为⼤写的情况，是把 bean 的⾸字```⺟也⼤写存储了
 	if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) && Character.isUpperCase(name.charAt(0))){
 		return name;
 	}
 	// 否则就将⾸字⺟⼩写
 	char chars[] = name.toCharArray();
 	chars[0] = Character.toLowerCase(chars[0]);
 	return new String(chars);
}

4. 为什么要这么多类注解

为什么需要这么多的类注解也是相同的原因，就是让程序员看到类注解之后，就能直接了解当前类的用途，比如：

  • @Controller：表示的是业务逻辑层；

  • @Servie：服务层；

  • @Repository：持久层；

  • @Configuration：配置层。

程序的工程分层，调用流程如下:

在这里插入图片描述

查看 @Controller / @Service / @Repository / @Configuration 等注解的源码发现：

在这里插入图片描述

其实这些注解里面都有一个注解 @Component，说明它们本身就是属于@Component 的“子类”。

5.方法注解 @Bean

注意事项:
在使用 @Bean 注解 的时候,必须要配合五大类注解一起使用
@Bean 获取时 @Bean 默认命名 = 方法名

package com.wjh.demo.model;

/**
 * @projectName: test-2023-11-23
 * @package: com.wjh.demo.service.model
 * @className: ArticleInfo
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/23 19:28
 * @version: 1.0
 */


import java.time.LocalDateTime;

/**
 *普通的文章实体类
 */

public class ArticleInfo {

    private int aid;
    private String title;
    private String content;
    private LocalDateTime createTime;

    public int getAid() {
        return aid;
    }

    public void setAid(int aid) {
        this.aid = aid;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public LocalDateTime getCreateTime() {
        return createTime;
    }

    public void setCreateTime(LocalDateTime createTime) {
        this.createTime = createTime;
    }

    @Override
    public String toString() {
        return "ArticleInfo{" +
                "aid=" + aid +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", createTime=" + createTime +
                '}';
    }
}


package com.wjh.demo.service;

import com.wjh.demo.model.ArticleInfo;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

/**
 * @projectName: test-2023-11-23
 * @package: com.wjh.demo.service
 * @className: Articles
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/23 19:33
 * @version: 1.0
 */
@Component
public class Articles {
    @Bean   //将当前方法返回的对象存储到 IoC 容器
    public ArticleInfo articleInfo() {
        //伪代码
        ArticleInfo articleInfo = new ArticleInfo();
        articleInfo.setAid(1);
        articleInfo.setTitle("今天周几?");
        articleInfo.setContent("今天周四!!");
        articleInfo.setCreateTime(LocalDateTime.now());
        return articleInfo;
    }
}

import com.wjh.demo.model.ArticleInfo;
import com.wjh.demo.service.UConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @projectName: test-2023-11-23
 * @package: PACKAGE_NAME
 * @className: App
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/22 19:16
 * @version: 1.0
 */
public class App {
    public static void main(String[] args) {
        //1.得到容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

        //2.得到 Bean 对象
        //User user = context.getBean("user",User.class);

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


        //Teacher teacher = context.getBean("teacher",Teacher.class);

        //UConfig uConfig = context.getBean("UConfig",UConfig.class);

        ArticleInfo articleInfo = context.getBean("articleInfo",ArticleInfo.class);

        //3.使用 Bean 对象
        //user.sayHello();

        // userService.sayHi();

        //teacher.sayHi();
        //uConfig.sayHi();

        System.out.println(articleInfo.toString());
    }
}

在这里插入图片描述

6.重命名 Bean 的几种方式

方式一:

在这里插入图片描述

package com.wjh.demo.service;

import com.wjh.demo.model.ArticleInfo;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

/**
 * @projectName: test-2023-11-23
 * @package: com.wjh.demo.service
 * @className: Articles
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/23 19:33
 * @version: 1.0
 */
@Component
public class Articles {
    @Bean("aaa")   //将当前方法返回的对象存储到 IoC 容器
    public ArticleInfo articleInfo() {
        //伪代码
        ArticleInfo articleInfo = new ArticleInfo();
        articleInfo.setAid(1);
        articleInfo.setTitle("今天周几?");
        articleInfo.setContent("今天周四!!");
        articleInfo.setCreateTime(LocalDateTime.now());
        return articleInfo;
    }
}

import com.wjh.demo.model.ArticleInfo;
import com.wjh.demo.service.UConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @projectName: test-2023-11-23
 * @package: PACKAGE_NAME
 * @className: App
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/22 19:16
 * @version: 1.0
 */
public class App {
    public static void main(String[] args) {
        //1.得到容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

        //2.得到 Bean 对象
        //User user = context.getBean("user",User.class);

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


        //Teacher teacher = context.getBean("teacher",Teacher.class);

        //UConfig uConfig = context.getBean("UConfig",UConfig.class);

        ArticleInfo articleInfo = context.getBean("aaa",ArticleInfo.class);

        //3.使用 Bean 对象
        //user.sayHello();

        // userService.sayHi();

        //teacher.sayHi();
        //uConfig.sayHi();

        System.out.println(articleInfo.toString());
    }
}

方式二:

在这里插入图片描述

package com.wjh.demo.service;

import com.wjh.demo.model.ArticleInfo;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

/**
 * @projectName: test-2023-11-23
 * @package: com.wjh.demo.service
 * @className: Articles
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/23 19:33
 * @version: 1.0
 */
@Component
public class Articles {
    @Bean(name = "bbb")   //将当前方法返回的对象存储到 IoC 容器
    public ArticleInfo articleInfo() {
        //伪代码
        ArticleInfo articleInfo = new ArticleInfo();
        articleInfo.setAid(1);
        articleInfo.setTitle("今天周几?");
        articleInfo.setContent("今天周四!!");
        articleInfo.setCreateTime(LocalDateTime.now());
        return articleInfo;
    }
}

import com.wjh.demo.model.ArticleInfo;
import com.wjh.demo.service.UConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @projectName: test-2023-11-23
 * @package: PACKAGE_NAME
 * @className: App
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/22 19:16
 * @version: 1.0
 */
public class App {
    public static void main(String[] args) {
        //1.得到容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

        //2.得到 Bean 对象
        //User user = context.getBean("user",User.class);

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


        //Teacher teacher = context.getBean("teacher",Teacher.class);

        //UConfig uConfig = context.getBean("UConfig",UConfig.class);

        ArticleInfo articleInfo = context.getBean("bbb",ArticleInfo.class);

        //3.使用 Bean 对象
        //user.sayHello();

        // userService.sayHi();

        //teacher.sayHi();
        //uConfig.sayHi();

        System.out.println(articleInfo.toString());
    }
}

方法三:

在这里插入图片描述

package com.wjh.demo.service;

import com.wjh.demo.model.ArticleInfo;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

/**
 * @projectName: test-2023-11-23
 * @package: com.wjh.demo.service
 * @className: Articles
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/23 19:33
 * @version: 1.0
 */
@Component
public class Articles {
    @Bean(name = {"bbb","ccc"})   //将当前方法返回的对象存储到 IoC 容器
    public ArticleInfo articleInfo() {
        //伪代码
        ArticleInfo articleInfo = new ArticleInfo();
        articleInfo.setAid(1);
        articleInfo.setTitle("今天周几?");
        articleInfo.setContent("今天周四!!");
        articleInfo.setCreateTime(LocalDateTime.now());
        return articleInfo;
    }
}

import com.wjh.demo.model.ArticleInfo;
import com.wjh.demo.service.UConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @projectName: test-2023-11-23
 * @package: PACKAGE_NAME
 * @className: App
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/22 19:16
 * @version: 1.0
 */
public class App {
    public static void main(String[] args) {
        //1.得到容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

        //2.得到 Bean 对象
        //User user = context.getBean("user",User.class);

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


        //Teacher teacher = context.getBean("teacher",Teacher.class);

        //UConfig uConfig = context.getBean("UConfig",UConfig.class);

        ArticleInfo articleInfo = context.getBean("bbb",ArticleInfo.class);

        //3.使用 Bean 对象
        //user.sayHello();

        // userService.sayHi();

        //teacher.sayHi();
        //uConfig.sayHi();

        System.out.println(articleInfo.toString());
    }
}

当使用 @Bean 重命名之后,此时在使用方法名获取 Bean 对象就不可行了

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

7.@Bean 的注意事项

如果多个 Bean 使用相同的名称,那么程序执行不会报错,但是第一个 Bean 之后的对象不会被存放到容器中,也就是只有在第一次创建 Bean 的时候会将对象和 Bean 的名称关联起来,后续再有相同名称的 Bean 存储时,容器会自动忽略

2.获取 Bean 对象

获取 bean 对象也叫做对象装配，是把对象取出来放到某个类中，有时候也叫对象注入。

对象装配（对象注入）的实现方法以下 3 种：

  1. 属性注入
  2. 构造方法注入
  3. Setter 注入

1.属性注入

在这里插入图片描述

package com.java.demo.dao;

import org.springframework.stereotype.Repository;

/**
 * @projectName: Demo
 * @package: com.java.demo.dao
 * @className: UserRepository
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/23 21:38
 * @version: 1.0
 */
@Repository
public class UserRepository {
    public int add() {
        System.out.println("Do UserRepository add method.");
        return 1;
    }
}


package com.java.demo.service;

import com.java.demo.dao.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Service;

/**
 * @projectName: Demo
 * @package: com.java.demo.service
 * @className: UserService
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/23 21:37
 * @version: 1.0
 */
@Service
public class UserService {

    //1.属性注入
    @Autowired   //DI (依赖注入)
    private UserRepository userRepository;

    public int add() {
        System.out.println("Do UserService add method.");
        /*//传统写法
        UserRepository userRepository = new UserRepository();
        return userRepository.add();*/


        /*//Spring 1.0
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

        UserRepository userRepository = context.getBean("userRepository",UserRepository.class);

        return userRepository.add();*/

        //Spring 2.0
        return userRepository.add();
    }
}


package com.java.demo.service;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.swing.*;

import static org.junit.jupiter.api.Assertions.*;


class UserServiceTest {

    @org.junit.jupiter.api.Test
    void add() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

在这里插入图片描述

依赖注入 VS 依赖查找

  • 依赖查找依赖 Bean 名称的
  • @Autowired 依赖注入流程:首先先根据 getType (从容器中) 获取对象,如果只获取到一个,那么直接将此对象注入到当前属性上,如果获取到多个对象,才会使用 getName(根据名称) 进行匹配.
@Component
public class Users {
    @Bean
    public User user1() {
        User user = new User();
        user.setId(1);
        user.setName("Java");
        return user;
    }
    @Bean
    public User user2() {
        User user = new User();
        user.setId(2);
        user.setName("MySQL");
        return user;
    }
}

@Controller
public class UserController4 {
    // 注⼊
    @Resource
    private User user;
    public User getUser() {
        return user;
    }
}

同类型的 Bean 存储到容器多个,获取时报错:

解决方案:

1.将属性的名字和 Bean 的名字对应上

2.@Autowired 配合 @Qualifier 一起使用

@Controller
public class UserController5 {
    // 注⼊
    @Autowired
    @Qualifier(value = "user2")
    private User user;
    public User getUser() {
        return user;
    }
}

使用属性注入的优缺点:

优点:简洁,使用简单

缺点:

1.无法注入 final 修饰的变量

在这里插入图片描述
被 final 修饰的变量需要直接赋值或构造方法中进行赋值
它不符合 Java 中 final 的使用规范，所以就不能注入成功了

2.通用性问题:使用属性注入的方式只适用于 IoC 框架（容器）

3.设计原则问题：更容易违背单一设计原则。

使用属性注入的方式，因为使用起来很简单，所以开发者很容易在一个类中同时注入多个对象，而这些对象的注入是否有必要？是否符合程序设计中的单一职责原则？就变成了一个问题。
但可以肯定的是，注入实现越简单，那么滥用它的概率也越大，所以出现违背单一职责原则的概率也越大。
注意：这里强调的是违背设计原则（单一职责）的可能性，而不是一定会违背设计原则，二者有着本质的区别。

2. Setter 注入

Setter 注入和属性的 Setter 方法实现类似，只不过在设置 set 方法的时候需要加上@Autowired 注解

package com.java.demo.service;

import com.java.demo.dao.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @projectName: test-2023-11-26
 * @package: com.java.demo.service
 * @className: UserService2
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/26 19:52
 * @version: 1.0
 */
@Service
public class UserService2 {

    private UserRepository userRepository;


    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    public void sayHello() {
        System.out.println("Do UserService2 sayHello");
        userRepository.add();
    }
}


package com.java.demo.service;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import static org.junit.jupiter.api.Assertions.*;

class UserService2Test {

    @Test
    void sayHello() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        UserService2 userService2 = context.getBean("userService2", UserService2.class);
        userService2.sayHello();
    }
}

在这里插入图片描述

Setter 注入的优缺点

优点:Setter 注入它完全符合单一职责的设计原则，因为每一个 Setter 只针对一个对象

缺点:

1.无法注入 一个 final 修饰的变量

在这里插入图片描述

2.Setter 注入的对象可以被修改,Setter 本来就是一个方法,既然是方法,就有可被多次调用和修改.

在这里插入图片描述

3.构造方法注入

标准的属性注入的写法

package com.java.demo.service;

import com.java.demo.dao.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @projectName: test-2023-11-26
 * @package: com.java.demo.service
 * @className: UserService3
 * @author: 王嘉辉
 * @description:
 * @date: 2023/11/26 20:13
 * @version: 1.0
 */
@Service
public class UserService3 {

    private UserRepository userRepository;

    @Autowired
    public UserService3(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void sayHi() {
        System.out.println("Do UserService3 sayHi");
        userRepository.add();
    }
}


package com.java.demo.service;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import static org.junit.jupiter.api.Assertions.*;

class UserService3Test {

    @Test
    void sayHi() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        UserService3 userService3 = context.getBean("userService3", UserService3.class);


        userService3.sayHi();
    }
}

在这里插入图片描述

如果只有一个构造方法，那么 @Autowired 注解可以省略

在这里插入图片描述

但是如果类中有多个构造方法，那么需要添加上 @Autowired 来明确指定到底使用哪个构造方法

在这里插入图片描述

构造方法注入的优缺点:

优点:

1.可注入一个 final 修饰的变量

在这里插入图片描述

2.注入对象不会被修改

构造方法注入不会像 Setter 注入那样，构造方法在对象创建时只会执行一次，因此它不存在注入对象被随时（调用）修改的情况。

3.注入对象会被完全初始化

因为依赖对象是在构造方法中执行的，而构造方法是在对象创建之初执行的，因此被注入的对象在使用之前，会被完全初始化，这也是构造方法注入的优点之一。

4.通用性更好

构造方法和属性注入不同，构造方法注入可适用于任何环境，无论是 IoC 框架还是非 IoC 框架，构造方法注入的代码都是通用的，所以它的通用性更好。

缺点:

1.写法比属性注入复杂

2.使用构造方法注入,解决不了循环依赖的问题(Spring 的三级缓存解决)

4.@Resource 另一种注入关键字

@Controller
public class UserController {
    // 注⼊
    @Resource
    private UserService userService;
    public User getUser(Integer id) {
        return userService.getUser(id);
    }
}

@Autowired 和 @Resource 的区别

  • 出身不同：@Autowired 来自于 Spring，而@Resource 来自于 JDK 的注解；

  • 使用时设置的参数不同：相比于 @Autowired 来说，@Resource 支持更多的参数设置，例如name 设置，根据名称获取 Bean。

  • @Autowired 可用于 Setter 注入、构造函数注入和属性注入，而@Resource 只能用于 Setter 注入和属性注入，不能用于构造函数注入

  • 使用@Autowired 在IDEA 专业版可能会误报,@Resource 不存在误报问题

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

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

相关文章

跟着chatgpt一起学|1.spark入门之MLLib

跟着chatgpt一起学|1.spark入门之MLLib

chatgpt在这一章表现的不好&#xff0c;所以我主要用它来帮我翻译文章提炼信息 1.前言 首先找到spark官网里关于MLLib的链接 spark内一共有2种支持机器学习的包&#xff0c; 一种是spark.ml,基于DataFrame的&#xff0c;也是目前主流的 另一种则是spark.mllib,是基于RDD的…
阅读更多...
MATLAB 和 Simulink 官方文档下载地址

MATLAB 和 Simulink 官方文档下载地址

MATLAB 官方文档中文版下载网址&#xff1a; https://ww2.mathworks.cn/help/pdf_doc/matlab/index.html 如图&#xff1a; MATLAB 官方文档英文版下载网址&#xff1a; https://ww2.mathworks.cn/help/pdf_doc/matlab/index.html?langen 如图&#xff1a; Simulink 官…
阅读更多...
02、Tensorflow实现手写数字识别（数字0-9）

02、Tensorflow实现手写数字识别（数字0-9）

02、Tensorflow实现手写数字识别&#xff08;数字0-9&#xff09; 开始学习机器学习啦&#xff0c;已经把吴恩达的课全部刷完了&#xff0c;现在开始熟悉一下复现代码。对这个手写数字实部比较感兴趣&#xff0c;作为入门的素材非常合适。 基于Tensorflow 2.10.0与pycharm 1…
阅读更多...
WebSocket协议测试实战

WebSocket协议测试实战

当涉及到WebSocket协议测试时&#xff0c;有几个关键方面需要考虑。在本文中&#xff0c;我们将探讨如何使用Python编写WebSocket测试&#xff0c;并使用一些常见的工具和库来简化测试过程。 1、什么是WebSocket协议&#xff1f; WebSocket是一种在客户端和服务器之间提供双向…
阅读更多...
基于OPC UA 的运动控制读书笔记（1）

基于OPC UA 的运动控制读书笔记（1）

最近一段时间集中研究OPCUA 在机器人控制应用中应用的可能性。这个话题自然离不开运动控制。 笔者对运动控制不是十分了解。于是恶补EtherCAT 驱动&#xff0c;PLCopen 运动控制的知识&#xff0c;下面是自己的读书笔记和实现OPCUA /IEC61499 运动控制器的实现方案设想。 PLCo…
阅读更多...
【Spring整合Junit】Spring整合Junit介绍

【Spring整合Junit】Spring整合Junit介绍

本文内容基于【Spring整合MyBatis】Spring整合MyBatis的具体方法进行测试 文章目录 1. 导入相关坐标2. 使用Junit测试所需注解3. 在测试类中写相关内容 1. 导入相关坐标 在pom.xml中导入相关坐标&#xff1a; <dependency><groupId>junit</groupId><ar…
阅读更多...
CSS常用笔记

CSS常用笔记

1. 脱离文档流&#xff0c;用于微调 {position: relative; top: 10px; right: 0; } 2. flex布局大法 <div class"demo"><div class"demo-1"></div><div class"demo-2"></div><div class"demo-3"&…
阅读更多...
Linux面试题（二）

Linux面试题（二）

目录 17、怎么使一个命令在后台运行? 18、利用 ps 怎么显示所有的进程? 怎么利用 ps 查看指定进程的信息&#xff1f; 19、哪个命令专门用来查看后台任务? 20、把后台任务调到前台执行使用什么命令?把停下的后台任务在后台执行起来用什么命令? 21、终止进程用什么命令…
阅读更多...
【计网 面向连接的传输TCP】 中科大笔记 （十 二）

【计网 面向连接的传输TCP】 中科大笔记 （十 二）

目录 0 引言1 TCP 的特性1.1 拓展&#xff1a;全双工、单工、半双工通信 2 TCP报文段结构3 TCP如何实现RDT4 TCP 流量控制4.1 题外话&#xff1a;算法感悟 5 TCP连接3次握手、断开连接4次握手5.1 连接5.2 断开连接 6 拥塞控制6.1 拥塞控制原理6.2 TCP拥塞控制 &#x1f64b;‍♂…
阅读更多...
shell脚本 ( 函数 数组 冒泡排序)

shell脚本 ( 函数 数组 冒泡排序)

目录 什么是函数 使用函数的方法 格式 注意事项 函数的使用 函数可以直接使用 函数变量的作用范围 函数返回值 查看函数 删除函数 函数的传递参数 使用函数文件 ​编辑 拓展递归函数 例&#xff1a;求5的阶乘 什么是数组 使用数组的方法 1.先声明 2.定义数组 3…
阅读更多...
Python---函数的数据---拆包的应用案例（两个变量值互换，*args, **kwargs调用时传递参数用法）

Python---函数的数据---拆包的应用案例（两个变量值互换，*args, **kwargs调用时传递参数用法）

案例&#xff1a; 使用至少3种方式交换两个变量的值 第一种方式&#xff1a;引入一个临时变量 c1 10 c2 2# 引入临时变量temp temp c2 c2 c1 c1 tempprint(c1, c2) 第二种方式&#xff1a;使用加法与减法运算交换两个变量的值&#xff08;不需要引入临时变量&#xff09…
阅读更多...
ArcGIS制作广场游客聚集状态及密度图

ArcGIS制作广场游客聚集状态及密度图

文章目录 一、加载实验数据二、平均最近邻法介绍1. 平均最近邻工具2. 广场游客聚集状态3. 结果分析三、游客密度制图一、加载实验数据 二、平均最近邻法介绍 1. 平均最近邻工具 “平均最近邻”工具将返回五个值：“平均观测距离”、“预期平均距离”、“最近邻指数”、z 得分和…
阅读更多...
C++学习之路（五）C++ 实现简单的文件管理系统命令行应用 - 示例代码拆分讲解

C++学习之路（五）C++ 实现简单的文件管理系统命令行应用 - 示例代码拆分讲解

简单的文件管理系统示例介绍: 这个文件管理系统示例是一个简单的命令行程序&#xff0c;允许用户进行文件的创建、读取、追加内容和删除操作。这个示例涉及了一些基本的文件操作和用户交互。 功能概述&#xff1a; 创建文件 (createFile())&#xff1a; 用户可以输入文件名和内…
阅读更多...
计算机系统的层次结构与性能指标

计算机系统的层次结构与性能指标

目录 一. 计算机系统的层次结构二. 计算机性能指标2.1. 存储器的性能指标2.2 CPU的性能指标2.3 系统整体的性能指标2.4 系统整体的性能指标(动态测试) \quad 一. 计算机系统的层次结构 \quad \quad 虚拟机器的意思是看起来像是机器直接就能执行程序员所写的代码, 其实是需要通过…
阅读更多...
Java王者荣耀

Java王者荣耀

一、创建项目 二、代码 package com.sxt;import javax.swing.*; import java.awt.*;public class Background extends GameObject {public Background(GameFrame gameFrame) {super(gameFrame);// TODO Auto-generated constructor stub}Image bg Toolkit.getDefaultToolkit(…
阅读更多...
基于helm的方式在k8s集群中部署gitlab - 备份恢复（二）

基于helm的方式在k8s集群中部署gitlab - 备份恢复（二）

接上一篇 基于helm的方式在k8s集群中部署gitlab - 部署&#xff08;一&#xff09;&#xff0c;本篇重点介绍在k8s集群中备份gitlab的数据&#xff0c;并在虚拟机上部署相同版本的gitlab&#xff0c;然后将备份的数据进行还原恢复 文章目录 1. 备份2. 恢复到虚拟机上的gitlab2.…
阅读更多...
java学习part13Object类和常用方法

java学习part13Object类和常用方法

1.Object 2.常用方法 2.1clone() clone()就是深拷贝&#xff0c;创建一个同内容新对象。需要实现接口 2.2finalize()已废弃 类似于析构函数&#xff0c;在GC回收之前调用。 System.gc()强制调用gc&#xff0c;然后就能看到finalize()的输出 2.3equals() 对于引用类型可用。…
阅读更多...
帮管客CRM SQL注入漏洞复现

帮管客CRM SQL注入漏洞复现

0x01 产品简介 帮管客CRM是一款集客户档案、销售记录、业务往来等功能于一体的客户管理系统。帮管客CRM客户管理系统&#xff0c;客户管理&#xff0c;从未如此简单&#xff0c;一个平台满足企业全方位的销售跟进、智能化服务管理、高效的沟通协同、图表化数据分析帮管客颠覆传…
阅读更多...
Linux（8）：BASH

Linux（8）：BASH

硬件、核心与 Shell 操作系统其实是一组软件&#xff0c;由于这组软件在控制整个硬件与管理系统的活动监测&#xff0c;如果这组软件能被用户随意的操作&#xff0c;若使用者应用不当&#xff0c;将会使得整个系统崩溃。因为操作系统管理的就是整个硬件功能。 应用程序在最外层…
阅读更多...
ELF分析（以CS:APP linkLab的文件为例）

ELF分析（以CS:APP linkLab的文件为例）

文件结构&#xff1a;gcc -o test main.o phase1.o 可执行文件的段头表&#xff08;又称程序头表&#xff09;&#xff08;用于描述本文件到虚拟内存的映射&#xff09; text文件的段头表如下。 上图有两个LOAD。它们的区别是权限不同。LOAD1是可读可执行&#xff08;这里面存…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023