Spring框架-Spring Bean管理

文章目录

    • Spring Bean管理
      • Spring Bean
      • 配置方式：
        • 使用XML配置方式：
          • User.java
          • applicationContext.xml
          • UserTest.java
        • 使用注解配置方式：
          • @Component
          • @Service
          • @Repository
          • @Configuration
          • @Scope
          • @Value
          • @Qualifier
          • @Primary
      • Bean的作用域和生命周期：
      • BeanFactory

Spring Bean管理

Spring Bean

通过之前的学习对SpringBean有了简单的认识。下面详细介绍一下SpringBean。

Spring Bean是任何由Spring容器管理的对象。可以通过配置文件，注解或者Java代码进行配置和创建。

在Spring中，Bean是Spring容器中的基本单位，Spring容器负责管理所有的Bean，包括创建，初始化，配置，销毁和依赖注入等。所有我们掌握bean的概念和使用方法对于理解和应用Spring框架是非常重要的。

Bean的定义

在Spring中，Bean的定义通常包括以下几个元素：

  • ID：Bean的唯一标识符。
  • Class：Bean的类型，通常是一个Java类。
  • Scope：Bean的作用域，通常有单例（Singleton）、原型（Prototype）、会话（Session）和请求（Request）四种。默认为单例。
  • Constructor arguments：Bean的构造函数参数。
  • Properties：Bean的属性。

Bean的依赖注入

在Spring中，依赖注入是一种将对象之间的依赖关系交给Spring容器管理的方式。当一个Bean需要使用另一个Bean时，它只需声明一个对该Bean的引用，并由Spring容器负责注入该Bean的实例。

Spring支持多种注入方式，包括构造函数注入、Setter方法注入、字段注入和接口注入等。其中，构造函数注入和Setter方法注入是最常用的两种方式。

配置方式：

Spring提供了多种方式来配置和创建Bean，包括XML配置、注解配置和Java配置。具体方法如下：

  • XML配置：通过在XML配置文件中定义Bean的标签和属性，可以告诉Spring如何创建和管理Bean。
  • 注解配置：通过在Bean的类上添加注解来告诉Spring如何创建和管理Bean。
  • Java配置：通过编写Java类来告诉Spring如何创建和管理Bean。
使用XML配置方式：
User.java
package com.sin.pojo;/*** @createTime 2024/1/2 15:56* @createAuthor SIN* @use*/
public class User {private String name;private int age;public User(String name, int age){this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?><!-- XML声明，xml版本和编码格式 --><!-- spring配置文件起点  -->
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 创建一个名为user的bean,对应的类是com.sin.pojo.User   --><bean id="user" class="com.sin.pojo.User"><!-- 通过构造方法注入两个参数值,0索引是String name,参数值为张三1索引是int age ,参数只为20--><constructor-arg index="0" value="张三"/><constructor-arg index="1" value="20"/></bean></beans>
UserTest.java
package com.sin.test;import com.sin.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** @createTime 2024/1/2 16:00* @createAuthor SIN* @use*/
public class UserTest {@Testpublic void test() {// 加载Spring配置文件ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");// 获取beanUser user = (User) context.getBean("user");// 使用bean输出数据System.out.println("姓名：" + user.getName());System.out.println("年龄：" + user.getAge());}
}
使用注解配置方式：

通过在Bean的类上添加注解来告诉Spring如何创建和管理Bean，常见的注解有：

注解说明
@Component是Spring框架的基本注解之一，用于将一个类标识为组件（Component）。被@Component注解标记的类将会被Spring容器自动扫描，并创建对应的Bean。它通常用于标记普通的Java类，表示这些类需要由Spring进行管理。
@Service是@Component注解的一个特化版本，用于标记一个类为服务（Service）层的组件。它表示该类是业务逻辑的实现类，通常用于在应用程序的服务层中使用。被@Service注解标记的类将被自动注册为Bean，并可以通过依赖注入在其他类中使用。
@Repository是@Component注解的一个特化版本，用于标记一个类为持久层（Repository）的组件。它表示该类用于访问和操作数据库或其他数据存储。被@Repository注解标记的类将被自动注册为Bean，并可以通过依赖注入在其他类中使用。
@Autowired是Spring框架的依赖注入注解，用于自动装配Bean之间的依赖关系。当一个类需要使用其他的Bean时，可以使用@Autowired注解在成员变量、构造方法或Setter方法上，Spring容器会自动将合适的Bean注入进来。通过@Autowired，我们可以避免手动实例化对象或配置Bean之间的关联关系。
@Configuration将一个类声明为配置类，用于定义应用程序的配置信息。通常与@Bean一起使用。
@Bean在配置类中使用该注解定义一个Bean。可以通过方法返回一个对象，并指定Bean的名称和类型。
@Scope用于指定Bean的作用域，即Bean的生命周期范围，如单例、原型等。常见的作用域包括Singleton（默认）、Prototype、Request、Session等。
@Value用于注入配置值或表达式到Bean属性中。可以用于从配置文件中获取值，或者使用SpEL表达式进行计算。
@Qualifier用于指定要注入的Bean的名称，当存在多个同类型的Bean时，可以通过该注解指定要注入的具体Bean。
@Primary用于标识某个Bean为首选的Bean，当存在多个同类型的Bean时，优先选择被@Primary注解标识的Bean。
@Component

UserService.java

package com.sin.service;import org.springframework.stereotype.Component;/*** @createTime 2024/1/2 16:42* @createAuthor SIN* @use*/
@Component
public class UserService {public String getUserInfo(){return "User information";}
}

UserTest.java

package com.sin.test;import com.sin.pojo.User;
import com.sin.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** @createTime 2024/1/2 16:00* @createAuthor SIN* @use*/
public class UserTest {@Testpublic void test() {// 加载Spring配置文件AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();// 注册UserService类context.register(UserService.class);// 启动Spring容器context.refresh();// 从容器中获取UserService实例UserService userService = context.getBean(UserService.class);System.out.println(userService.getUserInfo());// 关闭Spring容器context.close();}
}
@Service

UserService.java

package com.sin.service;import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;/*** @createTime 2024/1/2 16:42* @createAuthor SIN* @use*/
@Service
public class UserService {public String getUserInfo(){return "User information";}
}

UserTest.java

package com.sin.test;import com.sin.pojo.User;
import com.sin.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** @createTime 2024/1/2 16:00* @createAuthor SIN* @use*/
public class UserTest {@Testpublic void test() {// 加载Spring配置文件AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();// 注册包含@Service注解的类所在的包路径context.scan("com.sin.service");// 启动Spring容器context.refresh();// 从容器中获取UserService实例UserService userService = context.getBean(UserService.class);System.out.println(userService.getUserInfo());// 关闭Spring容器context.close();}
}
@Repository

UserDao.java

package com.sin.dao;import org.springframework.stereotype.Repository;/*** @createTime 2024/1/2 16:58* @createAuthor SIN* @use*/
@Repository
public class UserDao {public String getUserInfo(){return "从数据库中查找数据";}
}

UserService.java

package com.sin.service;import com.sin.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;/*** @createTime 2024/1/2 16:42* @createAuthor SIN* @use*/
@Service
public class UserService {@Autowiredprivate UserDao userDao;public String getUserInfo(){return userDao.getUserInfo();}
}

UserTest.java

package com.sin.test;import com.sin.pojo.User;
import com.sin.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** @createTime 2024/1/2 16:00* @createAuthor SIN* @use*/
public class UserTest {@Testpublic void test() {// 加载Spring配置文件AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();// 注册包含@Repository注解的类所在的包路径context.scan("com.sin.dao");// 注册包含@Service注解的类所在的包路径context.scan("com.sin.service");// 启动Spring容器context.refresh();// 从容器中获取UserService实例UserService userService = context.getBean(UserService.class);System.out.println(userService.getUserInfo());// 关闭Spring容器context.close();}
}
@Configuration

UserDao.java

package com.sin.dao;import org.springframework.stereotype.Repository;/*** @createTime 2024/1/2 16:58* @createAuthor SIN* @use*/
@Repository
public class UserDao {public String getUserInfo(){return "从数据库中查找数据";}
}

UserService.java

package com.sin.service;import com.sin.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;/*** @createTime 2024/1/2 16:42* @createAuthor SIN* @use*/
@Service
public class UserService {@Autowiredprivate UserDao userDao;public String getUserInfo(){return userDao.getUserInfo();}
}

AppConfig.java

package com.sin.config;import com.sin.dao.UserDao;
import com.sin.service.GreetingService;
import com.sin.service.UserService;
import com.sin.service.impl.GreetingServiceImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;/*** @createTime 2024/1/2 10:56* @createAuthor SIN* @use*/
@Configuration
@ComponentScan// 启动组件扫描，自动注册待用@Respository和@Service注解的类到Spring容器中
public class AppConfig {@Bean("userDao")public UserDao userDao(){return new UserDao();}@Bean("userService")public UserService userService(){return new UserService();}}

AppTest.java

package com.sin.test;import com.sin.config.AppConfig;
import com.sin.service.UserService;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;/*** @createTime 2024/1/2 17:14* @createAuthor SIN* @use*/
public class AppTest {@Testpublic void test(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);UserService userService = (UserService) context.getBean("userService");System.out.println(userService.getUserInfo());context.close();}
}
@Scope

MyBean.java

package com.sin.pojo;import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;/*** @createTime 2024/1/3 8:35* @createAuthor SIN* @use*/
@Component
@Scope("prototype")
public class MyBean {private String name;public MyBean(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

@Scope 是 Spring 框架中用于设置 bean 的作用域的注解之一。通过使用 @Scope 注解，我们可以指定 bean 的实例是单例（Singleton）还是原型（Prototype）等不同的作用域。

以下是 @Scope 注解的一些常见用法：

  • @Scope("singleton")：默认选项，表示 bean 是单例的，Spring 容器将只创建并管理一个 bean 实例。
  • @Scope("prototype")：表示 bean 是原型的，每次从容器中获取该 bean 时都会创建一个新的实例。
  • @Scope("request")：表示 bean 的生命周期与 HTTP 请求的生命周期相同，在每个请求处理过程中创建一个新的 bean 实例，并在请求结束后销毁。
  • @Scope("session")：表示 bean 的生命周期与 HTTP 会话的生命周期相同，在每个会话期间创建一个新的 bean 实例，并在会话结束后销毁。
  • @Scope("globalSession")：表示 bean 的生命周期与全局 HTTP 会话的生命周期相同，仅在使用基于 Portlet 的 web 应用程序时才有效。

AppConfig.java

package com.sin.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;/*** @createTime 2024/1/2 10:56* @createAuthor SIN* @use*/
@Configuration
@ComponentScan(basePackages = "com.sin.pojo") // 扫描组件
public class AppConfig {}

AppTest.java

package com.sin.test;import com.sin.config.AppConfig;
import com.sin.pojo.MyBean;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;/*** @createTime 2024/1/3 8:41* @createAuthor SIN* @use*/
public class AppTest {@Testpublic void test(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);MyBean bean1 = context.getBean(MyBean.class);bean1.setName("张三");System.out.println(bean1.getName());MyBean bean2 = context.getBean(MyBean.class);bean2.setName("李四");System.out.println(bean2.getName());}
}
@Value

app.properties

app.name : lisi

MyBean.java

package com.sin.pojo;import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;/*** @createTime 2024/1/3 8:35* @createAuthor SIN* @use*/
@Component
public class MyBean {@Value("李四")private String name;@Value("${app.name}")// 调用app.properties中的app.nameprivate String username;public String getName() {return name;}public void setName(String name) {this.name = name;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}
}

AppConfig.java

package com.sin.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;/*** @createTime 2024/1/2 10:56* @createAuthor SIN* @use*/
@Configuration
@ComponentScan(basePackages = "com.sin.pojo") // 扫描组件
@PropertySource("classpath:app.properties")// 指定属性文件的位置或者其他属性值的类型和名称，以便让spring加载其中定义的属性值
public class AppConfig {}

AppTest.java

package com.sin.test;import com.sin.config.AppConfig;
import com.sin.pojo.MyBean;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;/*** @createTime 2024/1/3 8:41* @createAuthor SIN* @use*/
public class AppTest {@Testpublic void test(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);MyBean bean1 = context.getBean(MyBean.class);System.out.println(bean1.getName());System.out.println(bean1.getUsername());}
}
@Qualifier

UserService.java

package com.sin.service;/*** @createTime 2024/1/3 9:10* @createAuthor SIN* @use*/
public interface UserService {public void addUser(String username);
}

UserServiceImpl1.java

package com.sin.service.impl;import com.sin.service.UserService;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;/*** @createTime 2024/1/3 9:10* @createAuthor SIN* @use*/
@Service
@Qualifier("userServiceImpl1")
public class UserServiceImpl1 implements UserService {@Overridepublic void addUser(String username) {System.out.println("添加的数据为"+ username + "位于 userServiceImpl1");}
}

UserServiceImpl2.java

package com.sin.service.impl;import com.sin.service.UserService;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;/*** @createTime 2024/1/3 9:12* @createAuthor SIN* @use*/
@Service
@Qualifier("userServiceImpl2")
public class UserServiceImpl2 implements UserService {@Overridepublic void addUser(String username) {System.out.println("添加的数据为"+ username + "位于 userServiceImpl2");}
}

AppConfig.java

package com.sin.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;/*** @createTime 2024/1/2 10:56* @createAuthor SIN* @use*/
@Configuration
@ComponentScan(basePackages = "com.sin.pojo") // 扫描组件
public class AppConfig {}

AppTest.java

package com.sin.test;import com.sin.config.AppConfig;
import com.sin.pojo.UserServiceClient;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;/*** @createTime 2024/1/3 8:41* @createAuthor SIN* @use*/
public class AppTest {@Testpublic void test(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);UserServiceClient userServiceClient = context.getBean(UserServiceClient.class);userServiceClient.addUser("张三");}
}
@Primary

UserService.java

package com.sin.service;/*** @createTime 2024/1/3 9:10* @createAuthor SIN* @use*/
public interface UserService {public void addUser(String username);
}

UserServiceImpl1.java

package com.sin.service.impl;import com.sin.service.UserService;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;/*** @createTime 2024/1/3 9:10* @createAuthor SIN* @use*/
@Service
public class UserServiceImpl1 implements UserService {@Overridepublic void addUser(String username) {System.out.println("添加的数据为"+ username + "位于 userServiceImpl1");}
}

UserServiceImpl2.java

package com.sin.service.impl;import com.sin.service.UserService;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;/*** @createTime 2024/1/3 9:12* @createAuthor SIN* @use*/
@Service
@Primary
public class UserServiceImpl2 implements UserService {@Overridepublic void addUser(String username) {System.out.println("添加的数据为"+ username + "位于 userServiceImpl2");}
}

UserServiceClient.java

package com.sin.pojo;import com.sin.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;/*** @createTime 2024/1/3 9:15* @createAuthor SIN* @use*/
@Component
public class UserServiceClient {private final UserService userService;public UserServiceClient(UserService userService) {this.userService = userService;}public void addUser(String username){userService.addUser(username);}
}

AppConfig.java

package com.sin.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;/*** @createTime 2024/1/2 10:56* @createAuthor SIN* @use*/
@Configuration
@ComponentScan(basePackages = "com.sin") // 扫描组件
public class AppConfig {}

AppTest.java

package com.sin.test;import com.sin.config.AppConfig;
import com.sin.pojo.UserServiceClient;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;/*** @createTime 2024/1/3 8:41* @createAuthor SIN* @use*/
public class AppTest {@Testpublic void test(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);UserServiceClient userServiceClient = context.getBean(UserServiceClient.class);userServiceClient.addUser("张三");}
}

Bean的作用域和生命周期：

Bean的作用域

Spring中Bean的作用域通常有四种：

  • 单例（Singleton）：在整个应用程序中只创建一个Bean实例。
  • 原型（Prototype）：每次请求Bean时都会创建一个新的实例。
  • 会话（Session）：在Web应用程序中，每个会话创建一个Bean实例。
  • 请求（Request）：在Web应用程序中，每个请求创建一个Bean实例。

Spring Bean的生命周期包括以下几个阶段：

  • 实例化：Spring容器根据Bean的定义，使用构造函数或者工厂方法创建Bean的实例。
  • 属性赋值：Spring容器将Bean的属性值注入到Bean实例中。
  • 初始化：Spring容器调用Bean的初始化方法，可以通过实现InitializingBean接口或者在配置文件中指定init-method来定义初始化方法。
  • 使用：Bean处于可用状态，可以被其他对象引用。
  • 销毁：Spring容器调用Bean的销毁方法，可以通过实现DisposableBean接口或者在配置文件中指定destroy-method来定义销毁方法。

BeanFactory

BeanFactory是Spring框架中的核心接口之一，Bean工厂用来管理和获取Spring Bean。它提供了一种延迟加载，懒加载的机制，只有在需要Bean的时候才会实例化和初始化。

BeanFacroty接口中常用的方法有：

方法说明
getBean(String name)根据给定的 Bean 名称获取对应的 Bean 实例
getBean(String name, Class requiredType)根据给定的 Bean 名称和类型获取对应的 Bean 实例
boolean containsBean(String name)判断容器中是否包含指定名称的 Bean
boolean isSingleton(String name)判断指定名称的 Bean 是否为单例模式
boolean isPrototype(String name)判断指定名称的 Bean 是否为原型模式
Class<?> getType(String name)获取指定名称的 Bean 的类型
String[] getAliases(String name)获取指定名称的 Bean 的别名

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?><!-- XML声明，xml版本和编码格式 --><!-- spring配置文件起点  -->
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="user" class="com.sin.pojo.User"></bean></beans>

AppTest.java

package com.sin.test;import com.sin.config.AppConfig;
import com.sin.pojo.User;
import com.sin.pojo.UserServiceClient;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** @createTime 2024/1/3 8:41* @createAuthor SIN* @use*/
public class AppTest {@Testpublic void test() {BeanFactory beanFactory = new ClassPathXmlApplicationContext("applicationContext.xml");System.out.println("获取的bean地址：" + beanFactory.getBean("user"));System.out.println("获取的bean地址：" + beanFactory.getBean("user", User.class));System.out.println("容器中是否存在user Bean"+beanFactory.containsBean("user"));System.out.println("是否为单例模式"+beanFactory.isSingleton("user"));System.out.println("是否为原型模式"+beanFactory.isPrototype("user"));System.out.println("获取到的类型为："+beanFactory.getType("user"));System.out.println("获取到的别名为："+beanFactory.getAliases("user"));}
}

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

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

相关文章

2023年广东省网络安全A模块（笔记详解）

2023年广东省网络安全A模块（笔记详解）

模块A 基础设施设置与安全加固 一、项目和任务描述&#xff1a; 假定你是某企业的网络安全工程师&#xff0c;对于企业的服务器系统&#xff0c;根据任务要求确保各服务正常运行&#xff0c;并通过综合运用登录和密码策略、流量完整性保护策略、事件监控策略、防火墙策略等多…
阅读更多...
企业数据资源入表，对数商企业有什么变化？释放了什么信号？

企业数据资源入表，对数商企业有什么变化？释放了什么信号？

不是必须的&#xff0c;二者没有必然联系。 数据资产入表的专业术语是数据资产会计核算。在《企业数据资源相关会计处理暂行规定》出台之前&#xff0c;很多企业的数据产品研究和开发阶段所产生的支出大都是费用化&#xff0c;直接计入损益表&#xff0c;但企业有一部分数据产…
阅读更多...
Linux习题4

Linux习题4

解析&#xff1a; 用二进制表示 rwx&#xff0c;r 代表可读&#xff0c;w 代表可写&#xff0c;x 代表可执行。如果可读&#xff0c;权限二进制为 100&#xff0c;十进制是4&#xff1b;如果可写&#xff0c;权限二进制为 010&#xff0c;十进制是2&#xff1b; 如果可执行&a…
阅读更多...
如何在Linux上部署1Panel面板并远程访问内网Web端管理界面

如何在Linux上部署1Panel面板并远程访问内网Web端管理界面

文章目录 前言1. Linux 安装1Panel2. 安装cpolar内网穿透3. 配置1Panel公网访问地址4. 公网远程访问1Panel管理界面5. 固定1Panel公网地址 前言 1Panel 是一个现代化、开源的 Linux 服务器运维管理面板。高效管理,通过 Web 端轻松管理 Linux 服务器&#xff0c;包括主机监控、…
阅读更多...
JAVA那些事（八）异常处理

JAVA那些事（八）异常处理

异常处理机制 Java中的异常处理机制是Java程序设计中非常重要的一个特性&#xff0c;它允许程序在出现错误或意外情况时进行适当的响应&#xff0c;而不是直接导致程序崩溃。异常处理遵循“捕获或者声明”原则&#xff0c;这意味着程序员要么捕获并处理可能发生的异常&#xf…
阅读更多...
ReactNative 常见问题及处理办法（加固混淆）

ReactNative 常见问题及处理办法（加固混淆）

文章目录 摘要 引言 正文ScrollView内无法滑动RN热更新中的文件引用问题RN中获取高度的技巧RN强制横屏UI适配问题低版本RN&#xff08;0.63以下&#xff09;适配iOS14图片无法显示问题RN清理缓存RN navigation参数取值pod install 或者npm install 443问题处理 打开要处理的…
阅读更多...
2023中国PostgreSQL数据库生态大会-核心PPT资料下载

2023中国PostgreSQL数据库生态大会-核心PPT资料下载

一、峰会简介 大会以“极速进化融合新生”为主题&#xff0c;探讨了PostgreSQL数据库生态的发展趋势和未来方向。 在大会主论坛上&#xff0c;专家们就PostgreSQL数据库的技术创新、应用实践和生态发展进行了深入交流。同时&#xff0c;大会还设置了技术创新&云原生论坛、…
阅读更多...
2023年后，AI 还有什么研究方向有前景？

2023年后，AI 还有什么研究方向有前景？

什么是AI ​ AI代表人工智能&#xff0c;它是指通过计算机科学技术使机器能够执行需要智力的任务的一种技术。这些任务包括学习、推理、问题解决和感知等&#xff0c;通常是人类智能的表现。人工智能的目标是使计算机系统能够执行需要人类智力的任务&#xff0c;而不需要人类的…
阅读更多...
国产高分七号光学影像产品预处理步骤

国产高分七号光学影像产品预处理步骤

1.引言 高分七号卫星采用主被动光学复合测绘新体制&#xff0c;星上搭载了双线阵相机、激光测高仪等有效载荷&#xff0c;其中双线阵相机可有效获取20公里幅宽、优于0.8m&#xff08;后视&#xff1a;0.65m;前视&#xff1a;0.8m&#xff09;分辨率的全色立体影像和2.6m分辨率的…
阅读更多...
Java中的Queue

Java中的Queue

Java中的Queue 在Java中&#xff0c;Queue 接口代表了一个队列数据结构&#xff0c;它按照先进先出&#xff08;First In, First Out&#xff0c;FIFO&#xff09;的原则进行元素的操作。Queue 接口扩展自 Collection 接口&#xff0c;定义了一系列方法&#xff0c;包括添加、删…
阅读更多...
JavaWeb——后端之Mybatis

JavaWeb——后端之Mybatis

四、Mybatis 概念&#xff1a; Mybatis是一款持久层&#xff08;Dao层&#xff09;框架&#xff0c;用于简化JDBC&#xff08;Sun操作数据库的规范&#xff0c;较繁琐&#xff09;的开发 历史&#xff1a; Apache的一个开源项目iBatis&#xff0c;2010年由apache迁移到了goog…
阅读更多...
Zookeeper(持续更新)

Zookeeper(持续更新)

VIP-01 Zookeeper特性与节点数据类型详解 文章目录 VIP-01 Zookeeper特性与节点数据类型详解正文1. 什么是Zookeeper&#xff1f;2. Zookeeper 核心概念2.1、 文件系统数据结构2.2、监听通知机制2.3、Zookeeper 经典的应用场景3.2. 使用命令行操作zookeeper 正文 什么是Zookee…
阅读更多...
初学编程，到底选Java还是C++?

初学编程，到底选Java还是C++?

初学编程&#xff0c;到底选Java还是C? 在开始前我有一些资料&#xff0c;是我根据网友给的问题精心整理了一份「C的资料从专业入门到高级教程」&#xff0c; 点个关注在评论区回复“888”之后私信回复“888”&#xff0c;全部无偿共享给大家&#xff01;&#xff01;&#x…
阅读更多...
LeGO-LOAM 安装以及运行

LeGO-LOAM 安装以及运行

一、源码地址&#xff1a; GitHub - RobustFieldAutonomyLab/LeGO-LOAM: LeGO-LOAM: Lightweight and Ground-Optimized Lidar Odometry and Mapping on Variable TerrainLeGO-LOAM: Lightweight and Ground-Optimized Lidar Odometry and Mapping on Variable Terrain - GitH…
阅读更多...
计算机网络问题

计算机网络问题

计算机网络问题 1、路由表中有环怎么办&#xff1f;&#xff08;字节&#xff09; 路由是网络层组件 什么是路由表&#xff1f; 什么是路由回路&#xff1f; 在维护路由表信息的时候&#xff0c;如果在拓扑发生改变后&#xff0c;网络收敛缓慢产生了不协调或者矛盾的路由选…
阅读更多...
【MySQL】如何选择字符集与排序规则（字符集校验规则）

【MySQL】如何选择字符集与排序规则（字符集校验规则）

思考 就中文而言&#xff0c;MySQL 中可以选择 gb2312 、utf8 及 utf8mb4 。这三种字符集有什么差异 &#xff1f;应该如何选择&#xff1f; 比较项gb2312utf8utf8mb4字符集范围简体中文字符集大部分 Unicode 字符更广泛的 Unicode 字符&#xff0c;包括罕见字符和 Emoji 表情…
阅读更多...
1688商品详情API：实现商品详情自动化的关键步骤

1688商品详情API：实现商品详情自动化的关键步骤

要实现商品详情的自动化&#xff0c;你可以遵循以下关键步骤&#xff1a; 明确需求和目标&#xff1a;首先&#xff0c;明确你想要通过自动化实现什么。是想要定期获取商品数据&#xff0c;进行数据分析&#xff0c;还是其他目的&#xff1f;确定目标有助于制定计划和步骤。集…
阅读更多...
异步任务判断执行和重复使用实现类

异步任务判断执行和重复使用实现类

主要是展示一下如何在书写异步任务判断的时候&#xff0c;如何根据返回值类型进行重复使用相同接口里面的不同实现类的方法 /*** 父类接口* **/ public interface Exceutor {String getTaskType();void excetuor(String s); }/*** 异步处理任务的任务类型** author yangziqian…
阅读更多...
arcpy点要素生成经纬度字段脚本

arcpy点要素生成经纬度字段脚本

说明 本脚本是用来简化操作的&#xff0c;正常情况下要生成经纬度字段&#xff0c;需要添加字段→填写字段名→写字段类型→字段计算器→计算几何。。。 而且经纬度都需要&#xff0c;要循环两遍。 本脚本就是为了简化以上操作的&#xff0c;安装后&#xff0c;打开脚本直接输…
阅读更多...
从《数据库索引设计与优化》看mysql索引设计

从《数据库索引设计与优化》看mysql索引设计

很久之前写的一篇文章&#xff0c;主要是结合mysql45讲和《数据库索引设计与优化》讨论索引设计的&#xff0c;拿出来分享下。 选用什么引擎 对于INSERT_SELECT型数据库&#xff0c;如果没有事务的要求&#xff0c;更倾向于选择MyISAM。 因为InnoDB会维护更多的数据&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023