Spring 简介

1. Spring简介

1.1 Spring 核心设计思想

1.1.1 Spring 是什么？

  • Spring 是包含了众多⼯具⽅法的 IoC 容器。
  • Spring 指的是 Spring Framework（Spring 框架），它是⼀个开源框架，Spring ⽀持⼴泛的应⽤场景，它可以让 Java 企业级的应⽤程序开发起来更简单。
1.1.1.1 什么是IoC容器？
  • 容器是⽤来容纳某种物品的装置。
  • IoC = Inversion of Control 翻译成中⽂是“控制反转”的意思，控制权发⽣的反转，不再是上级对象创建并控制下级对象了，⽽是下级对象把注⼊将当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发⽣任何改变，当前类都是不受影响的，这就是 IoC 的实现思想。
  • Spring具备两个核心功能：将对象存⼊到容器，从容器中取出对象。对象的创建和销毁的权利都交给 Spring 来管理了，它本身⼜具备了存储对象和获取对象的能⼒。
1.1.1.2 DI 概念说明

DI 是 Dependency Injection 的缩写，翻译成中⽂是“依赖注⼊”的意思。依赖注⼊就是由 IoC 容器在运⾏期间，动态地将某种依赖关系注⼊到对象之中。所以，依赖注⼊（DI）和控制反转（IoC）是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC 容器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦，IoC 是“⽬标”也是⼀种思想，⽽⽬标和思想只是⼀种指导原则，最终还是要有可⾏的落地⽅案，⽽ DI就属于具体的实现。

1.1.1.3 IoC容器和普通程序开发的区别
  • 将对象存储在 IoC 容器相当于将以后可能⽤的所有⼯具制作好都放到仓库中，需要的时候直接取就⾏了，⽤完再把它放回到仓库。
  • new 对象的⽅式相当于，每次需要工具了才现做，用完扔掉了也不会保存，下次再用的时候还得重新做。

1.2 Spring 创建和使用

在这里插入图片描述

1.2.1 创建 Spring 项目

使⽤ Maven ⽅式来创建⼀个 Spring 项⽬，创建 Spring 项⽬和 Servlet 类似。

  1. 创建⼀个 Maven 项⽬
    在这里插入图片描述
    然后跳转到了这个页面：
    在这里插入图片描述
  2. 添加 Spring 框架⽀持
    在项⽬的 pom.xml 中添加 Spring 框架的⽀持spring-context(spring 上下⽂)和spring-beans(管理对 象的模块),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>
  1. 添加启动类
    最后在创建好的项⽬ java ⽂件夹下创建⼀个启动类，包含 main ⽅法即可：
public class App {public static void main(String[] args) {}
}

到此为止，一个spring项目就搭建好了。

1.2.2 存储 Bean 对象

Bean 就是 Java 语⾔中的⼀个普通对象,例如：

public class User {public String sayHi(String name) { return name + " hello!";}
}
  1. 创建 Bean
public class User {public String sayHi(String name) { return name + " hello!";}
}
  1. 将 Bean 注册到容器
    <<1>>在创建好的项⽬中添加 Spring 配置⽂件 spring-config.xml，将此⽂件放到 resources 的根⽬录下， 如下图所示：
    在这里插入图片描述
    <<2>> 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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"></beans>

<<3>> 将 User 对象注册到 Spring 中就可以，在 标签中添加配置 ，格式如下：

<beans><bean id="user" class="com.bit.User"></bean>
</beans>

1.2.3 获取 Bean 对象

  1. 创建 Spring 上下⽂对象
    <<1>>使⽤ ApplicationContext

ApplicationContext context = new ClassPathXmlApplicationContext("spring-con fig.xml");

<<2>>使⽤ BeanFactory


BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

ApplicationContext VS BeanFactory

  • 继承关系和功能⽅⾯：Spring 容器有两个顶级的接⼝：BeanFactory 和 ApplicationContext。其中 BeanFactory 提供了基础的访问容器的能⼒，⽽ ApplicationContext 属于 BeanFactory 的⼦类，它除了继承了 BeanFactory 的所有功能之外，它还拥有独特的特性， 还添加了对国际化⽀持、资源访问⽀持、以及事件传播等⽅⾯的⽀持。
  • 性能⽅⾯：ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，⽽ BeanFactory 是需要那个才去加载那个，因此更加轻量。
    <<3>>使用ClassPathXmlApplicationContext
    ClassPathXmlApplicationContext 属于 ApplicationContext 的⼦类，拥有 ApplicationContext 的所有功能，通过 xml 的配置来获取所有的 Bean 容器。
  1. 获取指定的 Bean 对象
// 1.得到 Spring 上下⽂对象
ApplicationContext context = new ClassPathXmlApplicationContext("spring-con fig.xml");
// 2.加载某个 bean
User user = (User) context.getBean("user");

Bean 的 Id 要⼀⼀对应，如下图所示：
在这里插入图片描述

getBean ⽅法的更多⽤法

  • 根据类型获取 Bean：
UserController user = context.getBean(UserController.class);
  • 名称 + 类型获取 Bean：
UserController user = context.getBean("user", UserController.class);

当有⼀个类型被重复注册到 spring-config.xml 中时，只能使⽤根据名称获取了，⽐如以 下场景就会导致程序报错：在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.2.4 使用 Bean

public class App {public static void main(String[] args) {// 1.得到 Spring 上下⽂对象ApplicationContext context =new ClassPathXmlApplicationContext("spring-config.xml"); // 2.加载某个 beanUser user = (User) context.getBean("user");// 3.调⽤相应的⽅法System.out.println(user.sayHi("Java"));}
}

1.2.4 使用注解读取和存储对象

  1. 配置扫描路径

配置⼀下存储对象的扫描包路径，只有在被配置的包下且添加了注解的类才能被正确的识别并保存到 Spring 中。

在 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="com.bit.service"></content:component-scan></beans>

在这里插入图片描述

  1. 添加注解存储 Bean 对象
    将对象存储在 Spring 中，有两种注解类型可以实现：
  • 类注解：@Controller(表示业务逻辑层)、@Service(服务层)、@Repository(持久层)、@Component、@Configuration(配置层)。
  • ⽅法注解：@Bean
    类注解是添加到某个类上的，⽅法注解是放到某个⽅法上的。

Bean 命名规则：
通常 bean 使⽤的都是标准的⼤驼峰命名，读取的时候⾸字⺟⼩写：
在这里插入图片描述
当⾸字⺟和第⼆个字⺟都是⼤写时，不能正常读取到 bean ：
在这里插入图片描述
Spring中 bean 存储时⽣成的命名规则：
<1> 在 Idea 中使⽤搜索关键字“beanName”可以看到以下内容：
在这里插入图片描述
在这里插入图片描述
它使⽤的是 JDK Introspector 中的 decapitalize ⽅法，源码如下：

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);
}

所以对于上⾯报错的代码，只要改为以下代码就可以正常运⾏了：
在这里插入图片描述

类注解使用示例：

  • @Controller（控制器存储）
    使⽤ @Controller 存储 bean：
@Controller // 将对象存储到 Spring 中
public class UserController {public void sayHi(String name) {System.out.println("Hi," + name);}
}

先使⽤之前读取对象的⽅式读取上⾯的 UserController 对象：

public class Application {public static void main(String[] args) {// 1.得到 spring 上下⽂ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");// 2.得到 beanUserController userController = (UserController) context.getBean("userController");// 3.调⽤ bean ⽅法userController.sayHi("Bit");}
}
  • @Service（服务存储）
    使⽤ @Service 存储 bean
@Service
public class UserService {public void sayHi(String name) {System.out.println("Hi," + name);}
}

读取 bean

class App {public static void main(String[] args) {// 1.得到 spring 上下⽂ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");// 2.得到 beanUserService userService = (UserService) context.getBean("userService");// 3.调⽤ bean ⽅法userService.sayHi("Bit");}
}
  • @Repository（仓库存储）
    使⽤ @Repository 存储 bean
@Repository
public class UserRepository {public void sayHi(String name) {System.out.println("Hi," + name);}
}

读取 bean

class App {public static void main(String[] args) {// 1.得到 spring 上下⽂ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");// 2.得到某个 beanUserRepository userRepository = (UserRepository) context.getBean("userRepository");// 3.调⽤ bean ⽅法userRepository.sayHi("Bit");}
}
  • @Component（组件存储）
    使⽤ @Component 存储 bean
@Component
public class UserComponent {public void sayHi(String name) {System.out.println("Hi," + name);}
}

读取 bean

class App {public static void main(String[] args) {// 1.得到 spring 上下⽂ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");// 2.得到某个 beanUserComponent userComponent = (UserComponent) context.getBean("userComponent");// 3.调⽤ bean ⽅法userComponent.sayHi("Bit");}
}
  • @Configuration（配置存储）
@Configuration
public class UserConfiguration {public void sayHi(String name) {System.out.println("Hi," + name);}
}

读取 bean

class App {public static void main(String[] args) {// 1.得到 spring 上下⽂ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");// 2.得到某个 beanUserConfiguration userConfiguration = (UserConfiguration) context.getBean("userConfiguration");// 3.调⽤ bean ⽅法userConfiguration.sayHi("Bit");}
}

为什么有这么多功能一样的注解：
它们的功能都是一样的，让程序员看到类注解之后，就能直接了解当前类的⽤途。
程序的⼯程分层，调⽤流程：
在这里插入图片描述
查看 @Controller / @Service / @Repository / @Configuration 等注解的源码发现，这些注解⾥⾯都有⼀个注解 @Component，说明它们本身就是属于 @Component 的“⼦类”。
在这里插入图片描述

⽅法注解@Bean 使用示例：

⽅法注解要配合类注解使⽤
在 Spring 框架的设计中，⽅法注解 @Bean 要配合类注解才能将对象正常的存储到 Spring 容器中

  • 使用@Bean存储 bean

@Component
public class Users {@Beanpublic User user1() { User user = new User(); user.setId(1); user.setName("Java"); return user;}
}

读取bean

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

在这里插入图片描述

  • 重命名 Bean
    可以通过设置 name 属性给 Bean 对象进⾏重命名。重
@Component
public class Users { @Bean(name = {"u1"}) public User user1() { User user = new User(); user.setId(1); user.setName("Java"); return user;}
}

命名的 name 其实是⼀个数组，⼀个 bean 可以有多个名字。

@Bean(name = {"u1", "us1"}) public User user1() { User user = new User(); user.setId(1); user.setName("Java"); return user;
}

name={} 可以省略

@Bean({"u1", "us1"})
public User user1() { User user = new User(); user.setId(1); user.setName("Java"); return user;
}

此时使⽤ u1/us1 就可以获取到 User 对象了

class App {public static void main(String[] args) {// 1.得到 spring 上下⽂ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml"); // 2.得到某个 beanUser user = (User) context.getBean("u1");// 3.调⽤ bean ⽅法System.out.println(user);}
}
  1. 对象装配

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

<1> 属性注⼊

属性注⼊使⽤ @Autowired 实现。
属性注⼊的优点是简洁，使⽤⽅便；缺点是只能⽤于 IoC 容器，如果是⾮ IoC 容器不可⽤，并且只 有在使⽤的时候才会出现 NPE（空指针异常）。

示例：

Service 类的实现代码如下：

import org.springframework.stereotype.Service;@Service
public class UserService {/*** 根据 ID 获取⽤户数据** @param id* @return*/public User getUser(Integer id) { // 伪代码，不连接数据库 User user = new User(); user.setId(id); user.setName("Java-" + id); return user;}
}
  • Controller 类的实现代码如下：
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller;@Controller
public class UserController {// 注⼊⽅法1：属性注⼊ @Autowiredprivate UserService userService;public User getUser(Integer id) { return userService.getUser(id); }
}

核⼼实现：
在这里插入图片描述
获取 Controller 中的 getUser ⽅法：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class UserControllerTest {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml"); UserController userController = context.getBean(UserController.cla ss);System.out.println(userController.getUser(1).toString());}
}

运行结果：
在这里插入图片描述

<2>构造⽅法注⼊

构造⽅法注⼊是在类的构造⽅法中实现注⼊。
构造⽅法注⼊是 Spring 推荐的注⼊⽅式，它的缺点是如果有多个注⼊会显得⽐较臃肿，但出现这 种情况应该考虑⼀下当前类是否符合程序的单⼀职责的设计模式，优点是通⽤性，在使⽤之前⼀定能把保证注⼊的类不为空。

示例：

@Controller
public class UserController2 {// 注⼊⽅法2：构造⽅法注⼊ private UserService userService;     // 创建userService引用@Autowired public UserController2(UserService userService) {   // 注入并通过构造方法让上面的引用指向注入进来的这个对象this.userService = userService;}public User getUser(Integer id) { return userService.getUser(id); }
}

<<1>> 如果只有⼀个构造⽅法，那么 @Autowired 注解可以省略
在这里插入图片描述
<<2>>如果类中有多个构造⽅法，那么需要添加上 @Autowired 来明确指定到底使⽤哪个构造⽅法，否则 程序会报错
在这里插入图片描述

<3> Setter 注⼊

Setter 注⼊和 构造方法注入 实现类似，只不过在设置 set ⽅法的时候需要加上 @Autowired 注解。
Setter ⽅式是 Spring 前期版本推荐的注⼊⽅式，但通⽤性不如构造⽅法，所有 Spring 现版本已 经推荐使⽤构造⽅法注⼊的⽅式来进⾏类注⼊了。

示例：


@Controller
public class UserController3 {// 注⼊⽅法3：Setter注⼊ private UserService userService;@Autowiredpublic void setUserService(UserService userService) { this.userService = userService;}public User getUser(Integer id) { return userService.getUser(id); }
}

<4> @Resource注入

@Autowired 和 @Resource 的区别：

  • @Autowired 来⾃于 Spring，⽽ @Resource 来⾃于 JDK 的注解
  • 相⽐于 @Autowired ，@Resource ⽀持更多的参数设置，例如 name 设置，根据名称获取 Bean。
  • @Autowired 可⽤于 Setter 注⼊、构造方法注⼊和 属性注⼊。⽽ @Resource 只能⽤于 Setter 注⼊和 属性注⼊ 不能⽤于构造函数注⼊。

<5>使用同⼀类型多个 Bean 报错处理，当出现以下多个 Bean，返回同⼀对象类型时程序会报错。

示例：

@Component
public class Users {// 第一个bean@Beanpublic User user1() { User user = new User(); user.setId(1); user.setName("Java"); return user;}// 第二个bean@Beanpublic User user2() { User user = new User(); user.setId(2); user.setName("MySQL"); return user;}
}

在另⼀个类中获取 User 对象：

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

执⾏结果：
在这里插入图片描述
解决方法：
<<1>>使⽤ @Resource(name=“XXX”)来指定bean

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

<2> 使⽤ @Qualifier来指定bean

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

2. Bean 详解

2.1 Bean的作用域

限定程序中变量的可⽤范围叫做作⽤域，或者说在源代码中定义变量的某个区域就叫做作⽤域。
Bean 的作⽤域是指 Bean 在 Spring 整个框架中的某种⾏为模式。
Bean 有 6 种作⽤域：singleton(单例作⽤域)，prototype(原型作⽤域/多例作⽤域)， request(请求作⽤域)，session(回话作⽤域)，application(全局作⽤域)，websocket(HTTP WebSocket 作⽤域)。后 4 种状态是 Spring MVC 中的值，在普通的 Spring 项⽬中只有前两种。

2.1.1 singleton

Spring默认选择该作⽤域，该作⽤域下的Bean在IoC容器中只存在⼀个实例：获取Bean（即通过applicationContext.getBean等⽅法获取）及装配Bean（即通过@Autowired等注⼊）都是同⼀个对象。通常⽆状态的Bean（Bean对象的属性状态不需要更新）使⽤该作⽤域，单例可以很⼤程度上提⾼性能。
示例：
公共bean

@Component
public class Users {@Beanpublic User user1() {User user = new User();user.setId(1);user.setName("Java"); // 【重点：名称是 Java】return user;}
}

A ⽤户使⽤时，进⾏了修改操作：

@Controller
public class BeanScopesController {@Autowiredprivate User user1;public User getUser1() {User user = user1;System.out.println("Bean 原 Name：" + user.getName());user.setName("悟空"); // 【重点：进⾏了修改操作】return user;}
}

B ⽤户再去使⽤公共 Bean ：

@Controller
public class BeanScopesController2 {@Autowiredprivate User user1;public User getUser1() {User user = user1;return user;}
}

查看 A ⽤户和 B ⽤户公共 Bean 的值：

public class BeanScopesTest {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");BeanScopesController beanScopesController = context.getBean(BeanScopesController.class);System.out.println("A 对象修改之后 Name：" + beanScopesController.getUser1().toString());BeanScopesController2 beanScopesController2 = context.getBean(BeanScopesController2.class);System.out.println("B 对象读取到的 Name：" + beanScopesController2.getUser1().toString());}
}

执⾏结果：
在这里插入图片描述

2.1.2 prototype

每次对该作⽤域下的Bean的请求都会创建新的实例：获取Bean（即通过applicationContext.getBean等⽅法获取）及装配Bean（即通过@Autowired注⼊）都是新的对象实例。通常有状态（Bean对象的属性状态需要更新）的Bean使⽤该作⽤域。

2.1.3 request

每次http请求会创建新的Bean实例，类似于prototype。用于⼀次http的请求和响应的共享Bean，限定SpringMVC中使⽤。

2.1.4 session

在⼀个http session中，定义⼀个Bean实例，用于用户回话的共享Bean，⽐如：记录⼀个⽤户的登陆信息。限定SpringMVC中使⽤。

2.1.5 application

在⼀个http servlet Context中，定义⼀个Bean实例，用于Web应⽤的上下⽂信息，⽐如：记录⼀个应⽤的共享信息。限定SpringMVC中使⽤。

application 是 Spring Web 中的作⽤域，作⽤于 Servlet 容器。singleton 是 Spring Core 的作⽤域，singleton 作⽤于 IoC 的容器。

2.1.6 websocket

在⼀个HTTP WebSocket的⽣命周期中，定义⼀个Bean实例，用于WebSocket的每次会话中，保存了⼀个Map结构的头信息，将⽤来包裹客户端消息头。第⼀次初始化后，直到WebSocket结束都是同⼀个Bean。限定Spring WebSocket中使⽤。

2.2 设置Bean的作用域

使⽤ @Scope 标签就可以⽤来声明 Bean 的作⽤域。
<1> 直接设置值：@Scope(“prototype”)
<2> 使⽤枚举设置：@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

示例；

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Component
public class Users {@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)@Bean(name = "u1")public User user1() {User user = new User();user.setId(1);user.setName("Java"); // 【重点：名称是 Java】return user;}
}

2.2 Bean的生命周期

2.2.1 Spring 执行流程

在这里插入图片描述

2.2.2 Bean 的执行流程

启动 Spring 容器 --> 实例化 Bean(分配内存空间,从⽆到有) --> Bean注册到Spring中(存操作) --> 将Bean装配到需要的类中(取操作)。

2.2.3 Bean的生命周期

⽣命周期指的是⼀个对象从诞⽣到销毁的整个⽣命过程，我们把这个过程就叫做⼀个对象的⽣命周期。

在这里插入图片描述

  1. 实例化 Bean（为 Bean 分配内存空间）
  2. 设置属性（Bean 注⼊和装配）
  3. Bean 初始化
    3.1 实现了各种 Aware 通知的⽅法，如 BeanNameAware、BeanFactoryAware ApplicationContextAware >的接⼝⽅法；
    3.2 执⾏ BeanPostProcessor 初始化前置⽅法；
    3.3 执⾏ @PostConstruct 初始化⽅法，依赖注⼊操作之后被执⾏；
    3.4 执⾏⾃⼰指定的 init-method ⽅法（如果有指定的话）；
    3.5 执⾏ BeanPostProcessor 初始化后置⽅法。
  4. 使⽤ Bean
  5. 销毁 Bean。执行销毁容器的各种⽅法，如 @PreDestroy、DisposableBean 接⼝⽅法、destroy-method。
  • 实例化和初始化的区别：
    实例化和属性设置是 Java 级别的系统“事件”，其操作过程不可⼈⼯⼲预和修改；⽽初始化是给开发者 提供的，可以在实例化之后，类加载完成之前进⾏⾃定义“事件”处理。
  • 如何理解Bean生命周期：
    Bean 的⽣命流程看似繁琐，但咱们可以以⽣活中的场景来理解它，⽐如我们现在需要买⼀栋房⼦，那么我们的流程是这样的：
  1. 先买房（实例化，从⽆到有）；
  2. 装修（设置属性）；
  3. 买家电，如洗⾐机、冰箱、电视、空调等（[各种]初始化）；
  4. ⼊住（使⽤ Bean）；
  5. 卖出去（Bean 销毁）。

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

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

相关文章

月之暗面Kimi代码分析能力评测

月之暗面Kimi代码分析能力评测

最近打算重构一下PawSQL优化引擎中的OR条件的SELECT重写优化策略的代码&#xff0c;时间有点久&#xff0c;代码有点复杂&#xff0c;看到网上对新出了KIMI评价很高。于是尝试用它来理解一下代码。上传了此优化重写的代码&#xff0c;提问&#xff1a; 第一问&#xff0c;设计…
阅读更多...
java多线程编程面试题总结

java多线程编程面试题总结

一些最基本的基础知识就不总结了&#xff0c;参考之前写的如下几篇博客&#xff0c;阅读顺序从上到下&#xff0c;依次递进。 java 多线程 多线程概述及其三种创建方式 线程的常用方法 java 线程安全问题 三种线程同步方案 线程通信&#xff08;了解&#xff09; java 线程池…
阅读更多...
炸裂消息，全球首创全员持股短视频平台诞生

炸裂消息，全球首创全员持股短视频平台诞生

平台简介&#xff1a;享视是国内首家基于区块链打造的共益型短视频平台&#xff0c;也是全球首家真正践行共益模式的科技型创新企业&#xff0c;计划将80%的股权免费分发和共享给平台的会员&#xff0c;共同打造一家全员持股的共益商业模式示范标杆企业。 平台愿景&#xff1a…
阅读更多...
Spark Streaming DStream

Spark Streaming DStream

Spark Streaming DStream DStream 即Discretized Stream&#xff0c;中文叫做离散流&#xff0c;Spark Streaming提供的一种高级抽象&#xff0c;代表了一个持续不断的数据流。 DStream可以通过输入数据源来创建&#xff0c;比如Kafka、Flume&#xff0c;也可以通过对其他DS…
阅读更多...
主干网络篇 | YOLOv8更换主干网络之MobileNetV3

主干网络篇 | YOLOv8更换主干网络之MobileNetV3

前言：Hello大家好，我是小哥谈。MobileNetV3是一种轻量级的卷积神经网络架构，用于图像分类和目标检测任务。它是MobileNet系列的第三个版本，旨在在保持高准确性的同时减少模型的计算量和参数数量。MobileNetV3引入了一些新的设计思想和技术，以提高模型的性能。其中一项重要…
阅读更多...
【微服务】Gateway服务网关

【微服务】Gateway服务网关

&#x1f4dd;个人主页&#xff1a;五敷有你 &#x1f525;系列专栏&#xff1a;微服务 ⛺️稳中求进&#xff0c;晒太阳 Spring Cloud Gateway 是 Spring Cloud 的一个全新项目&#xff0c;该项目是基于 Spring 5.0&#xff0c;Spring Boot 2.0 和 Project Reactor 等响…
阅读更多...
Windows 7 静态 IP 地址

Windows 7 静态 IP 地址

Windows 7 静态 IP 地址 References 静态 IP 地址设置为 192.168.1.198 控制面板 -> 查看网络状态和任务 更改适配器设置 网络连接 -> 属性 TCP / IPv4 警告 - 已计划将多个默认网关用于提供单一网络 (例如 intranet 或者 Internet) 的冗余。 6.1. 关闭 redundancy VMw…
阅读更多...
个人博客系列-后端项目-系统角色配置（8）

个人博客系列-后端项目-系统角色配置（8）

系统角色配置需要设置的接口 用户可以绑定多个角色&#xff0c;角色对应有多个路由权限。用户绑定角色后&#xff0c;可以访问当前角色下的各个api路由和菜单路由。 用户注册时设置用户角色修改用户角色&#xff08;同时对应用户可以访问的路由将会同步变更&#xff09;添加修…
阅读更多...
【Linux】写个日志和再谈线程池

【Linux】写个日志和再谈线程池

欢迎来到Cefler的博客&#x1f601; &#x1f54c;博客主页&#xff1a;折纸花满衣 &#x1f3e0;个人专栏&#xff1a;信号量和线程池 目录 &#x1f449;&#x1f3fb;日志代码Log.cppMain.cc &#x1f449;&#x1f3fb;线程池代码LockGuard.hpp(自定义互斥锁&#xff0c;进…
阅读更多...
Spring Boot集成zxing实现生成二维码功能

Spring Boot集成zxing实现生成二维码功能

1.二维码介绍 二维码QR Code(Quick Response Code) 由Denso公司于1994年9月研制的一种矩阵二维码符号&#xff0c;它具有一维条码及其它二维条码所具有的信息容量大、可靠性高、可表示汉字及图象多种文字信息、保密防伪性强等优点。 ZXing 一个支持在图像中解码和生成条形码(如…
阅读更多...
【Web】NKCTF 2024 个人wp(部分)

【Web】NKCTF 2024 个人wp(部分)

目录 my first cms 全世界最简单的CTF attack_tacooooo 属实太菜了&#xff0c;3/4 my first cms 一眼搜版本2.2.19 CVE -CVE-2024-27622 GitHub - capture0x/CMSMadeSimple 访问/admin/login.php 爆出弱口令&#xff0c;后台登录 admin Admin123 Extensions > User D…
阅读更多...
鸿蒙实战开发-使用关系型数据库实现对账单的增、删、改、查

鸿蒙实战开发-使用关系型数据库实现对账单的增、删、改、查

介绍 本Codelab以记账为例&#xff0c;使用关系型数据库的相关接口实现了对账单的增、删、改、查操作。实现效果如图所示&#xff1a; 相关概念 关系型数据库&#xff1a;基于关系模型来管理数据的数据库&#xff0c;提供了增、删、改、查等接口&#xff0c;也可运行输入的SQ…
阅读更多...
Mac电脑高清媒体播放器:Movist Pro for mac下载

Mac电脑高清媒体播放器:Movist Pro for mac下载

Movist Pro for mac是一款专为Mac操作系统设计的高清媒体播放器&#xff0c;支持多种常见的媒体格式&#xff0c;包括MKV、AVI、MP4等&#xff0c;能够流畅播放高清视频和音频文件。Movist Pro具有强大的解码能力和优化的渲染引擎&#xff0c;让您享受到更清晰、更流畅的观影体…
阅读更多...
Matlab|【免费】基于数据驱动的模型预测控制电力系统机组组合优化

Matlab|【免费】基于数据驱动的模型预测控制电力系统机组组合优化

目录 1 主要内容 2 部分代码 3 程序结果 4 下载链接 1 主要内容 该程序复现文章《Feature-Driven Economic Improvement for Network-Constrained Unit Commitment: A Closed-Loop Predict-and-Optimize Framework》&#xff0c;程序主要做的是一个基于数据驱动的电力系统机…
阅读更多...
51单片机学习笔记——LED闪烁和流水灯

51单片机学习笔记——LED闪烁和流水灯

任务分析 首先要知道LED闪烁主要是怎么工作的&#xff0c;闪烁亮灭自然是一下为高一下为低&#xff0c;亮灭的频率则需要延时来进行控制。 上节已经知道了如何点亮那延时如何做呢首先先编写主框架 这样是否可以通过循环将LED灯一直循环闪烁。 以为while一直在循环所以其实是可…
阅读更多...
[Java基础揉碎]final关键字

[Java基础揉碎]final关键字

目录 介绍 在某些情况下&#xff0c;程序员可能有以下需求&#xff0c;就会使用到final final注意事项和讨论细节 1) final修饰的属性又叫常量&#xff0c;一般用XX_XX_XX来命名 2) final修饰的属性在定义时&#xff0c;必须赋初值&#xff0c;并且以后不能再修改&#…
阅读更多...
Spring Cloud五：Spring Cloud与持续集成/持续部署（CI/CD）

Spring Cloud五：Spring Cloud与持续集成/持续部署（CI/CD）

Spring Cloud一&#xff1a;Spring Cloud 简介 Spring Cloud二&#xff1a;核心组件解析 Spring Cloud三&#xff1a;API网关深入探索与实战应用 Spring Cloud四&#xff1a;微服务治理与安全 文章目录 一、Spring Cloud在CI/CD中的角色1. 服务注册与发现&#xff1a;自动化管理…
阅读更多...
Java安全 反序列化(4) CC1链-LazyMap版

Java安全 反序列化(4) CC1链-LazyMap版

Java安全 反序列化(4) CC1链-LazyMap版 实验环境:存在漏洞的版本 commons-collections3.1-3.2.1 jdk 8u71之后已修复不可利⽤ 文章目录 Java安全 反序列化(4) CC1链-LazyMap版一.跟踪挖掘CC1_LazyMap原理二.完整CC1_Lazy版Poc 接着上一篇文章我们通过ChainedTransFormer实现任意…
阅读更多...
client-go中ListAndWatch机制，informer源码详解

client-go中ListAndWatch机制，informer源码详解

文章首发地址&#xff1a; 学一下 (suxueit.com)https://suxueit.com/article_detail/s9UMb44BWZdDRfKqFv22 先上一张&#xff0c;不知道是那个大佬画的图 简单描述一下流程 client-go封装部分 以pod为例 、先List所有的Pod资源&#xff0c;然后通过已经获取的pod资源的最大版…
阅读更多...
SQLiteC/C++接口详细介绍sqlite3_stmt类（八）

SQLiteC/C++接口详细介绍sqlite3_stmt类（八）

返回&#xff1a;SQLite—系列文章目录 上一篇&#xff1a;SQLiteC/C接口详细介绍sqlite3_stmt类&#xff08;七&#xff09; 下一篇&#xff1a; SQLiteC/C接口详细介绍sqlite3_stmt类&#xff08;九&#xff09; 27、sqlite3_column_int 函数 sqlite3_column_int 用于返…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023