spring组件注册的几种方式

最新推荐文章于 2023-09-12 21:13:36 发布
最新推荐文章于 2023-09-12 21:13:36 发布
阅读量703 收藏 1
点赞数 1
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohuangaa/article/details/119748406
版权

目录

前言

最近学了一些spring注解的用法，记录一下

1. @Configuration和@Bean

1.1 大概介绍

@Configuration: 告诉spring当前类是一个配置类
@Bean：在配置类中使用添加组件
使用@Bean添加组件的时候，id默认是方法名。我们也可以自己在注解中设置id，比如@Bean(“person01”)


1.2 测试

配置类：

@Configuration
public class AddBeanConfig {

    @Bean
    public People people01(){
        People people = new People();
        people.setAge("18");
        people.setName("aaa");
        return people;
    }

    @Bean("people")
    public People people02(){
        People people = new People();
        people.setAge("19");
        people.setName("bbb");
        return people;
    }
}

测试类：

 @Test
    public void test(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AddBeanConfig.class);
        People people01 = (People)applicationContext.getBean("people01");
        People people = (People)applicationContext.getBean("people");
        System.out.println(people01);
        System.out.println(people);
        //Person{name='aaa', age='18'}
        //Person{name='bbb', age='19'}
    }



2. @ComponentScan+@Component

2.1 一般用法

@ComponentScan(“要扫描的包名”)，比如@ComponentScan(“com.test.bean”)就是扫面com.test.bean包，被扫描的类要加上@Component

@Component
public class Cat {
}

@Component
public class Dog {
}

@ComponentScan("com.test.bean")
@Configuration
public class AddBeanConfig {

    @Bean
    public People people01(){
        People people = new People();
        people.setAge("18");
        people.setName("aaa");
        return people;
    }

    @Bean("people")
    public People people02(){
        People people = new People();
        people.setAge("19");
        people.setName("bbb");
        return people;
    }
}

@Test
    public void test02(){
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
            //包含了下面两个
            //cat
            //dog
        }
    }



2.2 排除扫描一些类

在@ComponentScan注解内部有下面一段源码，提供了一个FIlter可以给我们用来包含或者排除某些组件，我们可以在Filter中写上自己要排除扫描的注解的类型，比如Controller，Service等等


	/**
	 * Declares the type filter to be used as an {@linkplain ComponentScan#includeFilters
	 * include filter} or {@linkplain ComponentScan#excludeFilters exclude filter}.
	 */
	@Retention(RetentionPolicy.RUNTIME)
	@Target({})
	@interface Filter {

		/**
		 * The type of filter to use.
		 * <p>Default is {@link FilterType#ANNOTATION}.
		 * @see #classes
		 * @see #pattern
		 */
		FilterType type() default FilterType.ANNOTATION;
		
		@AliasFor("classes")
		Class<?>[] value() default {};

		@AliasFor("value")
		Class<?>[] classes() default {};

	
		String[] pattern() default {};

	}


//测试：排除扫描Controller和Service
//配置类
@ComponentScan(value = "com.test",excludeFilters =
        {@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})}

)
@Configuration
public class AddBeanConfig {

}

//其他类
@Controller
public class UserController {
}

@Service
public class UserService {
}

@Repository
public class UserDao {
}

测试结果：

 @Test
    public void test02(){
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        //org.springframework.context.annotation.internalConfigurationAnnotationProcessor
        //org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        //org.springframework.context.annotation.internalCommonAnnotationProcessor
        //org.springframework.context.event.internalEventListenerProcessor
        //org.springframework.context.event.internalEventListenerFactory
        //addBeanConfig
        //userDao
    }



2.3 只扫描某些类

includeFilters = Filter[],指定按照某些规则只包含哪些包，注意一定要加上useDefaultFilters = false，不使用默认的过滤规则

//测试只扫描Controller注解
//配置类
@ComponentScan(value = "com.test",includeFilters =
        {@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class})}
        ,useDefaultFilters = false
)
@Configuration
public class AddBeanConfig {

}

//其他类
@Controller
public class UserController {
}

@Service
public class UserService {
}

@Repository
public class UserDao {
}

测试结果：

  @Test
    public void test02(){
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        //org.springframework.context.annotation.internalConfigurationAnnotationProcessor
        //org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        //org.springframework.context.annotation.internalCommonAnnotationProcessor
        //org.springframework.context.event.internalEventListenerProcessor
        //org.springframework.context.event.internalEventListenerFactory
        //addBeanConfig
        //userController
    }



2.4 @ComponentScans

ComponentScans：可以在里面指定多个ComponentScan的规则
在ComponentScan的源码中，可以看到有一个@Repeatable(ComponentScans.class)，也就是说，我们可以使用@ComponentScans注解重复添加ComponentScan

@Repeatable(ComponentScans.class)
public @interface ComponentScan {}

示例：

@ComponentScans(value = {
        @ComponentScan(value = "com.test", includeFilters = {
                @ComponentScan.Filter(type= FilterType.ANNOTATION, classes={Controller.class})
        }, useDefaultFilters = false)
})

2.5 自定义扫描规则

type= FilterType.ANNOTATION只是其中的一个，意思就是根据注解类型进行过滤。同时，spring还为我们提供了其他的一些规则。在这里我们测试ASSIGNABLE_TYPE和CUSTOM。

public enum FilterType {

    //注解类型
	ANNOTATION,

	//按照给定的类型
	ASSIGNABLE_TYPE,

	//使用ASPECTJ表达式
	ASPECTJ,

	//使用正则表达式
	REGEX,

	//自定义规则
	CUSTOM

}

2.5.1 ASSIGNABLE_TYPE

按照给定的类的类型进行过滤，比如我要单独扫描某一个类或者单独排除某一个类，就可以用这种方法

//这次把注解换成type = FilterType.ASSIGNABLE_TYPE，class就填我们要包含的类的类型，比如我们要只想扫描UserDao.class
@ComponentScan(value = "com.test",includeFilters =
        {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {UserDao.class})}
        ,useDefaultFilters = false
)

测试结果：

  @Test
    public void test02(){
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        //org.springframework.context.annotation.internalConfigurationAnnotationProcessor
        //org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        //org.springframework.context.annotation.internalCommonAnnotationProcessor
        //org.springframework.context.event.internalEventListenerProcessor
        //org.springframework.context.event.internalEventListenerFactory
        //addBeanConfig
        //userDao
    }

2.5.2 CUSTOM，自定义类型扫描

使用@ComponentScan.Filter(type = FilterType.CUSTOM)，我们可以写一个类实现TypeFilter 接口，在里面编写我们的自定义扫描代码逻辑。

//这里写逻辑，默认过滤dao的组件
public class MyFilter implements TypeFilter {

    /**
     * @param metadataReader 读取当前正在扫描的类的信息
     * @param metadataReaderFactory 可以获取到其他任何类的信息
     * @return
     * @throws IOException
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        //获取当前类注解信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        //获取当前正在扫描的类信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        //获取当前类的资源信息
        Resource resource = metadataReader.getResource();
        //获取当前类的类名
        String className = classMetadata.getClassName();
        //如果包含dao，就返回true
        if(className.contains("Dao")){
            return true;
        }
        return false;
    }
}

//这里根据我们的需求，只扫描MyFilter中的逻辑指定的组件类型，就是只扫描类名含有Dao的
@ComponentScan(value = "com.test",includeFilters =
        {@ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyFilter.class})}
        ,useDefaultFilters = false
)
@Configuration
public class AddBeanConfig {

}

 @Test
    public void test02(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AddBeanConfig.class);
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        //org.springframework.context.annotation.internalConfigurationAnnotationProcessor
        //org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        //org.springframework.context.annotation.internalCommonAnnotationProcessor
        //org.springframework.context.event.internalEventListenerProcessor
        //org.springframework.context.event.internalEventListenerFactory
        //addBeanConfig
        //userDao
    }



3. Scope注解

这其实不算是一种添加bean的方法，而是指定bean的类型的方法，比如指定bean是单实例还是多实例…
Scope的取值默认有四种，默认是单实例


	/**
		 --- prototype（多实例，IOC容器并不会在启动就创建，而是等getBean后才创建）
         --- singleton（单实例，默认这个,在ioc容器启动的时候会调用方法创建对象在IOC容器中，以后每次获取就回到IOC容器中拿）
         --- request（同一个请求创建一个实例，同一次请求只有一个实例bean）
         --- session（同一个session创建一个实例，同一个session只有一个实例bean）
	*/
	@AliasFor("value")
	String scopeName() default "";

我们当前默认是单实例bean的，在IOC容器启动的时候就会调用方法创建bean，以后每次获取都是直接从IOC容器中拿。

3.1 测试单实例bean

@ComponentScan
public class Tree {

    public Tree() {
        System.out.println("Tree 被创建了");
    }
}


@Configuration
public class AddBeanConfig {
	//此时没有加Scope，默认是单实例的
    @Bean
    public Tree tree(){
        return new Tree();
    }
}

测试类：（测试bean的创建和销毁）

 @Test
    public void test03(){
        //创建启动IOC容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AddBeanConfig.class);
        System.out.println("容器启动完成");
        Tree tree1 = (Tree)applicationContext.getBean("tree");
        Tree tree2 = (Tree)applicationContext.getBean("tree");
        System.out.println(tree1 == tree2);
        //true
        applicationContext.close();
    }

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

结论： 可以看到，我们在容器创建完成之前，就已经完成bean的创建了，在多次getBean的时候，获取到的是同一个bean。


3.2 测试多实例bean（懒加载）

@ComponentScan
public class Tree {

    public Tree() {
        System.out.println("Tree 被创建了");
    }
}


@Configuration
public class AddBeanConfig {
	//加了prototype，表示多实例
    @Bean
    @Scope("prototype")
    public Tree tree(){
        return new Tree();
    }
}

测试类：（测试bean的创建和销毁）

 @Test
    public void test03(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AddBeanConfig.class);
        System.out.println("容器创建完成");
        Tree tree1 = (Tree)applicationContext.getBean("tree");
        Tree tree2 = (Tree)applicationContext.getBean("tree");
        System.out.println(tree1 == tree2);
        applicationContext.close();
   
    }

在这里插入图片描述

结论：Tree被创建了2次，而且每次都是在容器创建完成后才创建tree的，最终也能看出来这两个tree不是同一个tree。



4. @Conditional

按照条件给容器添加bean，按照一定条件给容器中添加条件，满足需求才添加。

  1. 放在类上表示满足当前条件类中的bean才会加载
  2. 放在方法上表示满足当前条件方法才会生效
  3. 用法：实现Condition接口，重写matches方法

4.1 放在方法上

测试：根据不同的系统注册不同的bean

Condition 接口：

public class LinuxCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //获取到当前的环境
        Environment environment = context.getEnvironment();
        //获取操作系统的名字
        String property = environment.getProperty("os.name");
        if(property.contains("linux")){
            return true;
        }
        return false;
    }
}

public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //获取到当前的环境
        Environment environment = context.getEnvironment();
        //获取操作系统的名字
        String property = environment.getProperty("os.name");
        if(property.contains("Windows")){
            return true;
        }
        return false;
    }
}

Config：

@Configuration
public class AddBeanConfig {

    @Conditional({LinuxCondition.class})
    @Bean
    public People linux(){
        return new People("linux", "18");
    }

    @Conditional({WindowsCondition.class})
    @Bean
    public People window(){
        return new People("window", "18");
    }
}

test
```java
@Test
    public void test05(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AddBeanConfig.class);
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        //org.springframework.context.annotation.internalConfigurationAnnotationProcessor
        //org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        //org.springframework.context.annotation.internalCommonAnnotationProcessor
        //org.springframework.context.event.internalEventListenerProcessor
        //org.springframework.context.event.internalEventListenerFactory
        //addBeanConfig
        //window
    }

当前系统是window，所以注册了window组件，没有注册linux组件

4.2 放在类上

@Configuration
@ComponentScan("com.test")
public class AddBeanConfig {

    @Conditional({LinuxCondition.class})
    @Bean
    public People linux(){
        return new People("linux", "18");
    }

    @Conditional({WindowsCondition.class})
    @Bean
    public People window(){
        return new People("window", "18");
    }
}

//选择放在UserService 类上
@Conditional({LinuxCondition.class})
@Service
public class UserService {
}

测试结果：可以看到，由于我们不是linux系统，所以不会出现UserService的组件

@Test
    public void test05(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AddBeanConfig.class);
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        //org.springframework.context.annotation.internalConfigurationAnnotationProcessor
        //org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        //org.springframework.context.annotation.internalCommonAnnotationProcessor
        //org.springframework.context.event.internalEventListenerProcessor
        //org.springframework.context.event.internalEventListenerFactory
        //addBeanConfig
        //userController
        //userDao
        //window
    }



5. Import相关

源码：其实就是要导入哪一个类就写哪一个

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {

	Class<?>[] value();

}

5.1 import直接导入

直接在config类上面加上Import哪一个类就行，注意一点，import导入的bean的id是全类名

@Configuration
@Import({People.class})
public class AddBeanConfig {

}

测试：

//People被成功导入
@Test
    public void test06(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AddBeanConfig.class);
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        //org.springframework.context.annotation.internalConfigurationAnnotationProcessor
        //org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        //org.springframework.context.annotation.internalCommonAnnotationProcessor
        //org.springframework.context.event.internalEventListenerProcessor
        //org.springframework.context.event.internalEventListenerFactory
        //addBeanConfig
        //com.test.bean.People
    }

5.2 importSelector

除了第一种直接导入，import还为我们提供了其他的导入方法
在这里插入图片描述

用法就是：继承ImportSelector 接口,在selectImports里面返回全类名数组，注意要返回全类名

public class MyImportSeletor implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.test.bean.Cat", "com.test.bean.Dog"};
    }
}

接着在config类上面加上自己的importSelector类就可以了

@Configuration
@Import({People.class, MyImportSeletor.class})
public class AddBeanConfig {

}

测试结果：

@Test
    public void test06(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AddBeanConfig.class);
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        //org.springframework.context.annotation.internalConfigurationAnnotationProcessor
        //org.springframework.context.annotation.internalAutowiredAnnotationProcessor
        //org.springframework.context.annotation.internalCommonAnnotationProcessor
        //org.springframework.context.event.internalEventListenerProcessor
        //org.springframework.context.event.internalEventListenerFactory
        //addBeanConfig
        //com.test.bean.People
        //com.test.bean.Cat
        //com.test.bean.Dog
    }

5.3 ImportBeanDefinitionRegistrar

在这个方法中，我们可以直接注册bean，比如满足一定条件就注册哪个bean等等用途。使用的方法是继承ImportBeanDefinitionRegistrar 接口，在registerBeanDefinitions里面注册bean

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    /**
     * @param importingClassMetadata 当前类的信息
     * @param registry 注册类
     *  把所有需要添加到容器中的bean，调用registry.registerBeanDefinition来手动注册
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //指定bean信息
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Tree.class);
        //注册bean
        //参数1：bean名字    参数2：bean信息
        registry.registerBeanDefinition("myTree", rootBeanDefinition);
    }
}

加入到import中

@Configuration
@Import({People.class, MyImportSeletor.class, MyImportBeanDefinitionRegistrar.class})
public class AddBeanConfig {

}

测试结果：
在这里插入图片描述



6. FactoryBean

  • 使用spring提供的FactoryBean(工厂Bean)

1、继承FactoryBean,在getObject添加组件，getObjectType指定组件类型

public class MyFactory {

    private String call;

    public MyFactory() {
    }

    public MyFactory(String call) {
        this.call = call;
    }
}

//创建一个spring定义的工厂bean
public class MyFactoryBean implements FactoryBean {

    //返回一个对象，该对象会添加到容器中
    @Override
    public Object getObject() throws Exception {
        return new MyFactory("MyFactory被创建了");
    }

    //根据类型去容器中找bean
    @Override
    public Class<?> getObjectType() {
        return MyFactory.class;
    }

    //是不是单例
    //true:单例，在容器中保存一份
    // false：不是，每次调用都获取
    @Override
    public boolean isSingleton() {
        return true;
    }
}

2、配置类注册FactoryBean

@Configuration
@Import({People.class, MyImportSeletor.class, MyImportBeanDefinitionRegistrar.class})
public class AddBeanConfig {
    
    @Bean
    public MyFactoryBean myFactoryBean(){
        return new MyFactoryBean();
    }
}

3、测试,可以看到虽然注册的是MyFactoryBean，但是得到的是MyFactory

@Test
    public void test07(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AddBeanConfig.class);
        //提供FactoryBean获取组件
        MyFactory myFactory = (MyFactory)applicationContext.getBean("myFactoryBean");
        System.out.println(myFactory);
        //Tree 被创建了
        //com.jianglianghao.bean.MyFactory@1817d444
    }

4、获取MyFactoryBean本身，在BeanName前面加一个&就可以了

 MyFactoryBean myFactoryBean = (MyFactoryBean)applicationContext.getBean("&myFactoryBean");
        //com.jianglianghao.config.MyFactoryBean@1817d444






如有错误，欢迎指出

JWASX
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springbean的几种注入方式都了解吗
08-25
今天，我们将讨论 Spring Bean 的几种注入方式，并通过示例代码详细介绍每种方式的实现。 XML 注入 XML 注入是 Spring 框架中最早的注入方式。在 Spring Boot 框架出现之前，XML 配置被大量使用。虽然配置过程相对...
spring-注册组件的4种方法
weixin_37607613的博客
03-15 936
通过@ComponentScan扫描指定包，将包下的标注@Controller、@Service、@Repository、@Component的bean注册到IOC容器中。在配置类中使用@Bean注解将方法返回值对象注册到IOC容器中，id默认是方法名称，可通过value参数指定id。通过@Import注解将Bean注册到IOC容器中。通过工厂bean将bean注册到容器中。实现FactoryBean接口。...
Spring-Cloud 常用插件之 注册中心 eureka、consul
weixin_45626288的博客
09-21 976
springCloud 分布式架构 eureka 创建父maven项目，并添加依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.6.RELEASE</version> </parent> <
Spring注解之组件注册
weixin_42893756的博客
03-19 294
简记@ComponentScan1. @ComponentScan2. 参数3. excludeFilter与includeFilter4. FilterType.CUSTOM自定义5.测试6. 备注 1. @ComponentScan @ComponentScan是一个配置类的注解组件，作用于配置类，默认根据路径自动扫描该路径所在包下的所有类，并将其装载到Spring容器中，相当于xml配置文件中的<context:component-scan base-package=“路径”/> <
Srping 一、配置启动Spring 以及 SprigBean 注册方式
Tang的博客
08-14 122
一、导包 当我们创建Maven项目之后我们第一步就是需要在pom.xml文件中导入Spring的项目包 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <...
spring注册bean方式总结
weixin_43241706的博客
05-16 1837
spring注册bean的方式
spring依赖注入的几种方式
11-30
Spring 依赖注入的几种方式 依赖注入（Dependency Injection，简称 DI）是一种设计模式，它可以将对象之间的耦合关系降到最低，从而提高系统的灵活性和可维护性。在 Spring 框架中，依赖注入是通过 IoC 容器来实现...
spring装配bean的3种方式总结
08-26
Spring装配Bean的3种方式总结 Spring框架是Java EE应用程序的核心框架之一，它提供了依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）等功能。依赖注入是Spring框架的核心...
spring学习：依赖注入的几种方式讨论
08-09
Spring Boot引入了一种更智能的依赖注入方式——自动配置。自动配置是通过`@EnableAutoConfiguration`注解启动的，它根据项目中的类路径和特定条件自动配置Bean。例如，如果类路径下存在`MongoClient`的jar，Spring ...
关于spring boot中几种注入方法的一些个人看法
08-25
Spring Boot 中的几种注入方法 在 Spring Boot 中，注入是一种非常重要的机制，用于将 bean 对象注入到其他 bean 对象中，以便实现松耦合和高内聚的设计目标。下面我们将对 Spring Boot 中的几种注入方法进行详细的...
基于Spring框架实现用户的登陆和注册
04-19
体验Spring框架的使用，使用spring框架实现用户登陆和注册。设计一个应用程序，在该程序定义用户类、数据层和业务逻辑层。该程序会涉及到两张表：User表：用户名和密码；UserInfo表：编号，用户名，密码，真实姓名，地址，电话，邮箱，性别，年龄。
Spring注解开发之组件注册(一)
m0_55993923的博客
03-08 167
IOC，中文名为控制反转，是将Java的存储在中，当需要使用时，通过获取该对象。而不是通过new关键字去创建。本文包括@Configuration & @Bean给容器中注册组件，@ComponentScan 自动扫描组件，@Scope 设置组件作用域，@Conditional 按照条件注册bean
Spring框架的介绍和创建
瞭望红尘的博客
06-28 449
简介：Spring是一个轻量级的开发框架，目的是为了解决企业级应用开发的业务逻辑层和其他层之间的耦合问题。为开发Java程序提供了全面的基础框架支持，Spring负责基础架构，程序员负责专门的应用开发，不需要关注框架的底层具体实现。注：Spring最重要的两个核心特性，一个是依赖注入（DI，也叫IOC（控制反转）），一个是面向切面编程（AOP）。
Spring手动创建bean并注册工具类SpringBeanUtil
liufang1991的专栏
10-09 1329
import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.suppor
从设计模式理解Spring原理之注册器模式
JavaProfessional
06-26 754
读完本章你将获得：点击这里SpringIOC中有如下几个概念：我们今天想要讲解的就和这个比较陌生的概念BeanDefinition有关。Spring中每一个被扫到的bean都会生成一个BeanDefinition，包含bean的全部信息，如该bean的class类型、作用域、是否懒加载、初始化方法、销毁方法等等，其目的是为了防止重复解析导致效率变得低下。BeanDefinitionRegistry是一个接口，它定义了BeanDefinition的注册、移除、查询等一系列操作。我们先看看BeanDefinit
Spring更简单的注册和注入对象
weixin_46972127的博客
07-12 598
前言：经过前面的学习我们已经可以实现基本的Spring读取和存储对象的操作，但是操作过于复杂，所以接下来我们更进一步，学习更加简单的操作Bean对象的方法在Spring中想要更加简单的存储和读取对象的核心是使用注解想要将Bean添加到Spring中，我们需要配置一下存储对象的扫描路径，只有在被配置的包下的所有的类，添加了注解才能正确地存储到Spring中 想要将Bean对象存储到Spring中，有两种注解类型可以实现：① 类注解：@Controller（控制器）、@Service（服务）、@Reposito
Spring
weixin_44960905的博客
05-18 384
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.0.RELEASE</versio
Spring Boot实现登录注册的三种基本方式
最新发布
m0_52307083的博客
09-12 3552
setSigningKey()与builder中签名方法signWith()对应，parser中的此方法拥有与signWith()方法相同的三种参数形式，用于设置JWT的签名key，用户后面对JWT进行解析。方法很简单，以分隔符" . "，截取JWT第三段，即签名部分进行判断。使用sso微服务去认证，通过后保存token，再次验证时出示凭证即可获取登录信息。// 将用户的登录信息保存到Cookie中，有效期为7天。// 将用户的用户名更新为"Jane Doe"// 删除名为"user"的Cookie。
Spring不同注册方式
qq_45848415的博客
07-30 330
Spring 5 学习记录 XML 注册 创建applicationContext.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.
Spring 有几种配置方式
07-27
Spring有三种主要的配置方式： 1. XML配置：通过编写XML文件来配置Spring应用程序的各个组件，包括Bean定义、依赖注入、AOP等。这是Spring最早引入的配置方式，可以通过使用`<bean>`、`<property>`等元素来定义和配置组件。 2. 注解配置：通过在Java代码中使用注解来配置Spring应用程序。Spring提供了一系列注解，如`@Component`、`@Autowired`、`@Configuration`等，可以用于标记组件、注入依赖以及声明配置类。 3. Java配置：通过编写Java代码来配置Spring应用程序。这种方式是在Spring 3之后引入的，可以使用Java类和方法来定义和配置组件，而不需要XML文件。通常使用`@Configuration`注解标记配置类，并在其中使用`@Bean`注解声明Bean。 这三种配置方式可以单独使用，也可以混合使用，根据项目需求和个人偏好选择合适的方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值