Spring学习笔记1——Spring基础及组件使用

最新推荐文章于 2022-08-13 20:55:43 发布
最新推荐文章于 2022-08-13 20:55:43 发布
阅读量258 收藏 1
点赞数 1
分类专栏： Spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43415405/article/details/116994321
版权

Spring简介

  1. Spring是一种开源轻量级框架，是为了解决企业应用程序开发复杂性而创建的，Spring致力于解决Java EE的各层解决方案，而不仅仅于某一层的方案。

  2. 可以说Spring是企业应用开发的“一站式”选择，Spring贯穿于表现层、业务层、持久层，然而Spring并不想取代那些已经有的框架，而是以高度的开放性，与这些已有的框架进行整合。

  3. Spring是一个全面的解决方案，它坚持一个原则：不重新造轮子。已经有较好解决方案的领域，Spring绝不重复性实现，比如：对象持久化和OR映射，Spring只对现有的JDBC，Hibernate等技术提供支持，使之更容易使用，而不做重复的实现。Spring框架有很多特性，这些特性由7个定义良好的模块构成：

    • Spring Core：即，Spring核心，它是框架最基础的部分，提供IOC和依赖注入特性。
    • Spring Context：即，Spring上下文容器，它是BeanFactory功能加强的一个子接口。
    • Spring Web：它提供Web应用开发的支持。
    • Spring MVC：它针对Web应用中MVC思想的实现。
    • Spring DAO：提供对JDBC抽象层，简化了JDBC编码，同时，编码更具有健壮性。
    • Spring ORM：它支持用于流行的ORM框架的整合，比如：Spring+Hibernate、Spring+iBatis、Spring+JDO的整合等等。
    • Spring AOP：AOP即，面向切面编程，它提供了与AOP联盟兼容的编程实现。

  4. Spring常用组件：
    在这里插入图片描述

xml配置与@Configuration注解配置

  1. xml配置方式：

    beans.xml主要代码如下：

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="..." ...>
    <!-- Person类定义在此省略 -->
	<bean id ="person" class="com.study.spring.Person">
        <property name="name" value="yhl"></property>
        <property name="age" value="18"></property>
    </bean>
</beans>

    测试类主要代码如下：

    public class MainTest1{
    public static void main(String args[]){
        // 把beans.xml中的类加载到容器中
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
        // 从容器中获取bean
        Person person = (Person) app.getBean("person");
        System.out.println(person);
    }
}

  2. 注解配置方式：

    配置类主要代码如下：

    // 配置类，相当于配置文件
@Configuration
public class MainConfig{
    // 给容器中注册一个bean，类型为返回值的类型
    @Bean
    public Person person(){
        return new Person("yhl",19);
    }
}

    测试类主要代码如下：

    public class MainTest2{
    public static void main(String args[]){
       ApplicationContext app = new AnnotationConfigApplicationContext(MainConfig.class);
        // 从容器中获取bean
        Person person = (Person) app.getBean("person");
        System.out.println(person);
    }
}

  3. @Configuration与beans.xml作用一样，@Configuration更简单、灵活

@ComponentScan扫描规则

  1. 可以定制包扫描时的过滤规则，比如，以下代码会扫描出@Controller和BookService：

    @Configuration
@ComponentScan(value="com.study.spring",includeFilters={
    @Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
    @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class})
},useDefaultFilters=false) 
public class MainConfig2 {
    // 给容器中注册一个bean，类型为返回值的类型
    @Bean
    public Person person01(){
        return new Person("yhl",19);
    }
}

  2. @ComponentScan注解的属性：

    • value：指定要扫描的包。
    • excludeFilters = Filter[]：指定扫描的时候按照什么规则排除哪些组件。
    • includeFilters = Filter[]：指定扫描的时候只需要包含哪些组件。
    • useDefaultFilters = false：默认是true扫描所有组件，要改成false，才能使用自定义扫描范围。

  3. @Filter的扫描规则如下：

    • FilterType.ANNOTATION：按照注解，比如@Controller、@Service、@Repository、@Component注解。
    • FilterType.ASSIGNABLE_TYPE：按照给定的类型，比如BookService类型。
    • FilterType.ASPECTJ：使用ASPECTJ表达式。
    • FilterType.REGEX：使用正则指定。
    • FilterType.CUSTOM：使用自定义规则，自已写类，实现TypeFilter接口。

  4. 自定义规则示例：

    public class YhlTypeFilter implements TypeFilter{
    
    private ClassMetadata classMetadata;
    
    /*
     * MetadataReader：读取到当前正在扫描类的信息
     * MetadataReaderFactory：可以获取到其他任何类的信息
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException{
        // 获取当前类注解的信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        // 获取当前正在扫描的类信息
        classMetadata = metadataReader.getClassMetadata();
        // 获取当前类资源（类的路径）
        Resource resource = meatadataReader.getResource();
        
        String className = classMetadata.getClassName();
        System.out.println("--->" + className);
        
        // 当类包含er字符，则匹配成功，返回true
        if(className.contains("er")){
            return true;
        }
        return false;
    }
}

    @Configuration
@ComponentScan(value="com.study.spring",includeFilters={
    @Filter(type=FilterType.CUSTOM,classes={YhlTypeFilter.class})
},useDefaultFilters=false) 
public class MainConfig2 {
    // 给容器中注册一个bean，类型为返回值的类型
    @Bean
    public Person person(){
        return new Person("yhl",19);
    }
}

@Scope扫描规则

  1. @Scope注解的值：

    • prototype：多实例，IOC容器启动的时候并不会取调用方法创建对象，而是每次获取的时候才会调用方法创建对象。
    • singleton：单实例（默认），IOC容器启动的时候会调用方法创建对象并放到IOC容器中，以后每次获取的就是直接从容器中拿的同一个bean。
    • request：主要针对web应用，递交一次请求创建一个实例。
    • session：同一个session创建一个实例。

  2. 没加@Scope之前, 默认的bean是单实例的。

  3. 比如，以下代码指定bean为多实例：

    @Configuration
public class MainConfig3{
    // 给容器中注册一个bean，类型为返回值的类型，默认是单实例
    @Scope("prototype")
    @Bean
    public Person person(){
        return new Person("yhl",19);
    }
}

@Lazy懒加载

  1. 主要针对单实例bean（单实例bean默认在容器启动的时候创建对象），使用懒加载后，容器启动的时候不创建对象，仅当第一次使用（获取）bean的时候才创建并初始化。

  2. 示例如下：

    @Configuration
public class MainConfig4{
    // 给容器中注册一个bean，类型为返回值的类型，默认是单实例
    @Lazy
    @Bean
    public Person person(){
        return new Person("yhl",19);
    }
}

@Conditional条件注册bean

  1. 当引入@Conditional时, 容器可以选择性的注册bean。比如，当操作系统为WINDOWS时,注册yhl1实例; 当操作系统为LINUX时, 注册yhl2实例：

    // 配置类
@Configuration
public class MainConfig5{
    
    @Conditional({WinCondition.class})
    @Bean("yhl1")
    public Person yhl1(){
        return new Person("yhl1",19);
    }
    
    @Conditional({LinuxCondition.class})
    @Bean("yhl2")
    public Person yhl2(){
        return new Person("yhl2",20);
    }
}

    // 条件类，必须得实现Spring提供的Confition接口
public class WinCondition implements Condition{
	
	/*
	 * ConditionContext: 判断条件能使用的上下文(环境)
	 * AnnotatedTypeMetadata: 注释信息
	 */
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 能获取到IOC容器正在使用的beanFactory
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 获取当前环境变量（包括操作系统时WIN还是LINUX)
		Environment environment = context.getEnvironment();
		String os_name = environment.getProperty("os.name");
		if(os_name.contains("Windows")){
			return true;
		}
		return false;
	}
}

    // 条件类，必须得实现Spring提供的Confition接口
public class LinCondition implements Condition{

	/*
	 * ConditionContext: 判断条件能使用的上下文(环境)
	 * AnnotatedTypeMetadata: 注释信息
	 */
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		// 能获取到IOC容器正在使用的beanFactory
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		// 获取当前环境变量（包括操作系统时WIN还是LINUX)
		Environment environment = context.getEnvironment();
		String os_name = environment.getProperty("os.name");
		if(os_name.contains("linux")){
			return true;
		}
		return false;
	}
}

  2. FactoryBean与BeanFactory的区别：可以把Java实例bean通过FactoryBean注入到容器中；BeanFactory从容器中获取实例化后的bean。

@Import注册bean

  1. 给容器注册组件的方式：

    • @Bean：导入第三方的类或包的组件，比如Person为第三方的类，需要在IOC容器中使用。
    • 包扫描+组件的标注注解（@ComponentScan：@Controller、@Service、@Repository、@Component）：一般是针对自己写的类，使用这个。
    • @Import：快速给容器导入一个组件。@Bean有点简单。
      • @Import(要导入到容器中的组件)：容器会自动注册这个组件，bean的id为全类名
      • ImportSelector：是一个接口，返回需要导入到容器的组件的全类名数组
      • ImportBeanDefinitionRegistrar：可以手动添加组件到IOC容器，所有bean的注册可以使用BeanDefinitionRegistry，写YhlImportBeanDefinitionRegistrar实现ImportBeanDefinitionRegistrar接口即可
    • 使用Spring提供的FactoryBean（工厂Bean）进行注册：容器调用getObject()返回对象，把对象放到容器中；getObjectType()返回对象类型；isSingleton()是否单例进行控制。新建YhlFactoryBean实现FactoryBean，在config里新建yhlFactoryBean()方法。

  2. 使用@Import将dog、cat的bean注册到容器中：

    @Configuration
// 导入组件，ID默认是组件的全类名
@Import(value = {Dog.class,Cat.class})
public class MainConfig6 {

    // 容器启动时初始化person的bean实例
    @Bean
	public Person person(){
        return new Person("yhl",19);
    }
}

  3. ImportSelector可以批量导入组件的全类名数组,自定义逻辑返回需要导入的组件：

    public class YhlImportSelector implements ImportSelector{
	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata){
		// 返回全类名的bean
		return new String[]{"com.study.spring.Fish","com.study.spring.Tiger"};
	}
}

    @Configuration
@Import(value = {Dog.class,Cat.class,YhlImportSelector.class})
public class MainConfig7 {

    // 容器启动时初始化person的bean实例
    @Bean
	public Person person(){
        return new Person("yhl",19);
    }
}

  4. 通过ImportBeanDefinitionRegistrar自定义注册,向容器中注册bean：

    public class YhlImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

	/*
	 * AnnotationMetadata:当前类的注解信息
	 * BeanDefinitionRegistry:BeanDefinition注册类，把所有需要添加到容器中的bean加入
	 * 调用BeanDefinitionRegistry.registerBeanDefinition自定义手工注册进来
	 */
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		boolean bean1 = registry.containsBeanDefinition("com.study.spring.Dog");
		boolean bean2 = registry.containsBeanDefinition("com.study.spring.Cat");
		// 如果Dog和Cat同时存在于IOC容器中，那么创建Pig类，加入到容器
		if(bean1 && bean2){
            // 以前的bean都是全类名，现在自定义bean名
            // 对于要注册的bean，需要给bean进行封装
			RootBeanDefinition beanDefinition = new RootBeanDefinition(Pig.class);
            // 注册一个bean，bean名为pig
			registry.registerBeanDefinition("pig", beanDefinition);
		}
	}

}

    @Configuration
@Import(value = {Dog.class,Cat.class,YhlImportSelector.class,YhlImportBeanDefinitionRegistrar.class})
public class MainConfig8 {

    // 容器启动时初始化person的bean实例
    @Bean
	public Person person(){
        return new Person("yhl",19);
    }
}

  5. 通过实现FactoryBean接口方式来加载bean：

    public class YhlFactoryBean implements FactoryBean<Monkey>{

	@Override
	public Monkey getObject() throws Exception {
		return new Monkey();
	}

	@Override
	public Class<?> getObjectType() {
		return Monkey.class;
	}
	
	@Override
	public boolean isSingleton() {
		return true;
	}
}

    @Configuration
public class MainConfig9 {

    @Bean
	public YhlFactoryBean yhlFactoryBean(){
		return new YhlFactoryBean();
	}
}

    默认获取到的是工厂bean调用getObject创建的对象，要获取工厂bean本身，需要在id前加个yhlFactoryBean。

bean生命周期

  1. bean的生命周期是指**bean创建-----初始化----销毁**的过程，是由容器进行管理的。

  2. 可以自定义 bean初始化和销毁方法：容器在bean进行到当前生命周期的时候, 来调用自定义的初始化和销毁方法，有3种方式：

    • 指定初始化和销毁方法：

      • 在beans.xml中可以指定init-method和destory-mothod。

      • 用注释的话，在配置类里通过@Bean(initMethod="init",destroyMethod="destroy")指定。

        @Bean(initMethod="init", destroyMethod="destory")
public Bike bike(){
    return new Bike();
}

        单实例：当容器关闭的时候，会调用destroy消耗。

        多实例：容器只负责初始化，但不会管理bean，容器关闭不会调用销毁方法。

    • 让Bean实现InitializingBean和DisposableBean接口：

      • InitializingBean（定义初始化逻辑）：afterPropertiesSet()方法：当beanFactory创建好对象，且把bean所有属性设置好之后，会调这个方法，相当于初始化方法。
      • DisposableBean（定义销毁逻辑）：destory()方法，当bean销毁时，会把单实例bean进行销毁。
      @Component
public class Train implements InitializingBean, DisposableBean{

	public Train(){
		System.out.println("Train......constructor............");
	}
	// 当bean销毁时，调用此方法
	@Override
	public void destroy() throws Exception {
		System.out.println("Train......destory......");
		//logger.error
	}
	// 当bean属性赋值和初始化完成时调用
	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("Train.......afterPropertiesSet()...");
		
	}

}

    • 使用JSR250规则定义的（java规范）两个注解来实现：

      • @PostConstruct：在bean创建完成，且赋值完成后进行初始化，属于JDK规范的注解。
      • @PreDestroy：在bean将被移除之前进行通知，在容器销毁之前进行清理工作。
      @Component
public class Jeep {
	public Jeep(){
		System.out.println("Jeep.....constructor........");
	}
	@PostConstruct
	public void init(){
		System.out.println("Jeep.....@PostConstruct........");
	}
	
	@PreDestroy
	public void destory(){
		System.out.println("Jeep.....@PreDestroy......");
	}
}

  3. BeanPostProcessor类（interface）是bean的后置处理器，负责在初始化方法前后进行一些处理工作：

    • postProcessBeforeInitialization()：在初始化之前进行后置处理工作（在init-method之前）。在任何初始化方法调用之前调用此方法（比如在InitializingBean的afterPropertiesSet初始化之前，或自定义init-method调用之前使用）。
    • postProcessAfterInitialization()：在初始化之后进行后置处理工作，比如在InitializingBean的afterPropertiesSet()之后。
    /*
 * 后置处理器：初始化前后进行处理工作
 * 将后置处理器加入到容器中
 */
@Component
public class YhlBeanPostProcessor implements BeanPostProcessor{
    
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessBeforeInitialization...."+beanName+"..."+bean);
		// 返回一个对象（传过来的对象），也可包装好再返回
        return bean;
	}
    
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessAfterInitialization...."+beanName+"..."+bean);
		return bean;
	}
}
Willow51
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Spring（一）spring基础及组件使用1、2、3
Mr.Tac
01-26 168
仅以此记录spring学习笔记 spring框架： spring --> IOC --> DI Dog dog = new Dog(); IOC管理 IOC就是对bean进行管理：bean注册、实例化管理 application.xml --> <bean id = 'dog' class = "com.ca.Dog"> 使用注解 IOC容器：Map java bean实例 map.put(beanId,Bean) 多实例：仅当bean被使用的时.
spring-1、基础及组件使用
weixin_44215154的博客
05-10 129
Spring 是一种开源轻量级框架，是为了解决企业应用程序开发复杂性而创建的， Spring 致力于解决 JavaEE 的各种解决方案，而不仅仅于某一层的方案； 贯穿于表现层、业务层、持久层，然而并没有取代已有框架，只是以高度的开放性，与已有框架进行整合； 目标： 1、让现有的技术更容易使用。 1、促进良好的编程习惯。 坚持一个原则：不重复造轮子。 已经有较好解决方案的领域，绝不重复性实现。比如：对象持久化和OR 映射，Spring 只对现有的JDBC，Hibernate 等技术提供支持，使之更容易使用，
Spring-01-基础及组件使用
程序yuan同学
04-14 99
chapter01： 从xml配置到注解 1，创建maven工程 2，pom.xml引入spring-context.jar和Junit测试用例包 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId>
Spring归纳小结（山东数漫江湖）
abc_1114的博客
04-24 276
前言 如果说有什么框架是Java程序员必然会学习、使用到的，那么Spring肯定是其中之一。本篇博客，将根据博主在日常工作中对Spring的使用做一个系统的归纳小结。 Spring的一些概念和思想 Spring的核心：AOP、IOC。 简单点说，就是把对象交给Spring进行管理，通过面向切面编程来实现一些"模板式"的操作，使得程序员解放出来，可以更加关注业务实...
spring组件学习
走不动的木木
11-05 210
本文主要记录学习到的spring组件以及spring组件设置。 给spring容器中注册组件 通过使用注解方式向spring容器中添加组件是十分简单的，大体有如下方式： 在config类中通过添加@Bean来添加注解 通过扫描添加组件 使用@Import添加一个外部组件 使用@ImportSelector添加一个组件 使用ImportBeanDefinitionRegistrar添加一个组件 使...
JavaEE精讲之Spring框架实战 ——学习笔记.zip
09-18
在本学习笔记中，我们将深入探讨JavaEE中的Spring框架，这是一个强大的、全面的企业级应用程序开发框架，它简化了Java开发并提供了丰富的功能。Spring的核心特性包括依赖注入（DI）、面向切面编程（AOP）以及对Java ...
Spring学习笔记+学习源码.zip
05-12
这份"Spring学习笔记+学习源码.zip"资源包含了深入学习Spring及其相关技术的知识点，以及实践代码，对提升Spring技能将大有裨益。 首先，我们来详细讨论Spring框架的主要组件和功能： 1. **依赖注入（Dependency ...
Spring学习笔记1之IOC详解尽量使用注解以及java代码
09-02
在本文中，我们将深入探讨Spring框架中的重要概念——控制反转（Inversion of Control，简称IOC），并重点关注如何通过注解和Java配置来实现IOC。Spring是Java开发中广泛使用的轻量级框架，它简化了应用程序的构建，...
java框架学习笔记spring笔记
最新发布
12-19
4. **Spring MVC**：Spring 提供了一个用于构建 Web 应用的模块——Spring MVC。它遵循 Model-View-Controller 设计模式，使得开发人员能够清晰地分离业务逻辑、数据模型和用户界面。Spring MVC 包括 ...
spring5学习笔记
01-23
《Spring5学习笔记详解》 在当今的Java开发领域，Spring框架无疑是最为广泛使用的轻量级框架之一，尤其在Spring5版本发布后，其功能更加强大且易用。本篇文章将根据提供的文件名，深入探讨Spring5的核心概念、特性...
01、Spring基础及入门
雄的博客
12-04 171
1. Spring是什么 Spring是一种开源轻量级框架，是为了解决企业应用程序开发复杂性而创建的，Spring致力于解决JavaEE的各层解决方案，而不仅仅于某一层的方案。 2. Spring的发展历程 2003年2月Spring框架正式称为一道开源项目，Spring致力于J2EE应用的各种解决方案，而不仅仅专注于某一层解决方案。可以说Spring是企业应用开发的“一站式”选择， Spring...
Spring Boot [组件学习-Spring]
weixin_33729196的博客
03-06 116
导读： 在上篇文章的结尾提到了Spring Boot 提供了一系列的框架整合（Starter POMs)帮助我们提升开发效率,但是这并不意味着我们不需要学习这些框架，反而更需要去学习，通过学习这些框架可以使我们更好的去解决生产中遇到的问题。 在这篇文章中主要以Spring Framework作为起步点，带你快速了解Spring Fram...
Spring Cloud组件学习概要
zhanggang807的专栏
05-20 172
Eureka 注册中心 去中心化，高可用，CAP中满足AP（与zk不同，满足CP） RESTFUL风格接口，服务端可查看集群信息，http://localhost:8761 客化端可通过RESTFUL调用接口，http://localhost:8762/ 客户端server list缓存 Ribbon 负载均衡 ...
spring学习23-基础组件
qq_41632427的博客
08-13 85
spring
Spring学习笔记(一)----Spring的基本概念
Stephen GS的博客
03-16 315
Spring是什么
Spring框架
weixin_30832405的博客
06-22 1443
Spring的概述 　　Spring是一种开源轻量级框架，是为了解决企业应用程序开发复杂性而创建的，Spring致力于解决JavaEE的各层解决方案，而不仅仅于某一层的方案。 　　由Rod Johnson创建的一个开源框架。Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻...
【架构视角】一篇文章带你彻底吃透Spring
潘潘和他的朋友们
04-28 1373
框架，本质上是一些实用经验集合。即是前辈们在实际开发过程中积攒下来的实战经验，累积成一套实用工具，避免你在开发过程中重复去造轮子，特别是帮你把日常中能遇到的场景或问题都给屏蔽掉，框架的意义在于屏蔽掉开发的基础复杂度、屏蔽掉此类共性的东西，同时建立严格的编码规范，让框架使用者开箱即用，并且只需要关注差异面，即业务层面的实现。简而言之，框架只干一件事，那就是简化开发。然后在此基础上，可能会再考虑一些安全性、效率、性能、弹性、管理、拓展、解耦等等。
Spring核心思想 IOC 、 AOP
weixin_44796239的博客
10-29 1100
Spring核心思想 IOC 、 AOP 注意：IOC和AOP不是spring提出的，在spring之前就已经存在，只不过更偏向于理论化，spring在技术层次把这两个思想做了⾮常好的实现（Java） IOC 1、什么是IOC？ IoC Inversion of Control (控制反转/反转控制)，注意它是⼀个技术思想，不是⼀个技术实现描述的事情：Java开发领域对象的创建，管理的问题 传统开发⽅式：⽐如类A依赖于类B，往往会在类A中new⼀个B的对象 IoC思想下开发⽅式：我们不⽤⾃⼰去new对象了，
万字大章学习Spring
Lotus_dong的博客
02-20 661
文章目录SpringSpring的核心及优点Spring的核心Spring的优点Spring环境搭建Spring IOCSpring IOC创建对象的方式Spring DI注入利用DI进行解决DI注入的方式构造完成注入属性注入自动注入Spring AOP代理模式实现AOP什么是代理模式？动态代理基于AspectJ实现AOPAspectJ实现五种通知类型Spring中的常用注解Spring事务Spring事务特征Spring事务管理形式Spring事务管理的实现Spring事务传播行为Spring集成MyBa
spring个人学习笔记
03-04
关于spring的一些配置和使用,更加方便的学习spring，仅供参考

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值