Spring学习笔记(1)

这篇具有很好参考价值的文章主要介绍了Spring学习笔记(1)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、Spring基础介绍

1.1 Spring的学习路线

Spring学习笔记(1),spring,学习,笔记

1.2 Spring解决传统的JavaWeb开发的缺点

问题一: 层与层之前联系在一起,耦合性高(接口与实现类相互联系)

解决方法: Spring提供了第三方来自动加载对象,不用自己手动new出对象,第三方自动提供Bean对象

Spring学习笔记(1),spring,学习,笔记
问题二:通用的事务功能耦合在业务代码中,通用的日志功能耦合在业务代码中

  • 通用的事务功能指的是一些通用的数据库事务操作,比如开启事务、提交事务、回滚事务等。将这些通用的事务功能耦合在业务代码中意味着业务代码需要自己实现这些事务操作,导致业务代码与事务代码混杂在一起,代码可读性和可维护性降低。
  • 这种情况下,业务代码需要关注事务的处理,而不是专注于业务逻辑本身,从而增加了代码的复杂度和维护难度。此外,如果多个业务模块都需要使用同样的事务功能,那么这些业务模块都需要独立实现,增加了代码重复度和开发成本。

解决方法: 程序当中不用自己手动去new出对象,第三方可以根据需求去创建程序需要的Bean对象的代理对象

Spring学习笔记(1),spring,学习,笔记

1.3 Spring当中的三种思想

  1. IoC:lnversion of Control,控制反转,强调的是原来在程序中创建Bean的权利反转给第三方。
  2. DI:Dependency Injection,依赖注入,强调的Bean之间关系,这种关系第三方负责去设置。
  3. AOP:Aspect Oriented Programming,面向切面编程,功能的横向抽取,主要的实现方式就是Proxy

Spring学习笔记(1),spring,学习,笔记

1.4 框架的基本特点

  • 框架(Framework),是基于基础技术之上,从众多业务中抽取出的通用解决方案;
  • 框架是一个半成品,使用框架规定的语法开发可以提高开发效率可以用简单的代码就能完成复杂的基础业务;
  • 框架内部使用大量的设计模式、算法、底层代码操作技术,如反射、内省、xml解析、注解解析等;
  • 框架一般都具备扩展性;
  • 有了框架,我们可以将精力尽可能的投入在纯业务开发上而不用去费心技术实现以及一些辅助业务。

Java中常用的框架:

不同语言,不同领域都有属于自己的框架,使用框架开发是作为程序员的最基础的底线,基本所有的程序员都需要掌握一种框架给予自己开发。

Java语言中的框架,可以分为基础框架和服务框架:

  • 基础框架:完成基本业务操作的框架,如MyBatis、Spring、SpringMVC、Struts2、Hibernate等
  • 服务框架:特定领域的框架,一般还可以对外提供服务框架,如MQ、ES、Nacos等

1.5 Spring概述

spring是一个开源的轻量级Java开发应用框架,可以简化企业级应用开发。Spring解决了开发者在JavaEE开发中遇到的许多常见的问题,提供了功能强大IOC、AOP及Web MVC等功能。是当前企业中Java开发几乎不能缺少的框架之一。Spring的生态及其完善,不管是Spring哪个领域的解决方案都是依附于在Spring Framework基础框架的。

  • Spring框架的历史
    • Jsp 默默扛下所有;
    • MVC+三层架构分工明确,但开发成本及其高;
    • EJB重量级框架出现,走出一个困境,有进入另一个困境;
    • Spring春天来到,随之,SSH风生水起、称霸武林;
    • Spring 稳住江湖大哥位置,SSM开始上位;、
    • Spring本着“拿来主义”的思维快速发展,生态不断健全;
    • SpringBoot 又一里程碑崛起,把“约定大于配置“思想玩儿的炉火纯青;
    • SpringCloud打包了微服务众多解决方案,应对互联网项目更加简单

Spring Farmework包含框架内容:
Spring学习笔记(1),spring,学习,笔记

1.6 BeanFactory快速入门

Spring学习笔记(1),spring,学习,笔记

1. 导入Spring当中的jar包

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.3.7</version>
</dependency>

2. 定义userService和其实现的接口userServiceImpl

public interface UserService {
}
public class UserServiceImpl implements UserService {
} 

3. 创建bean.xml配置文件,将UserServiceImpl信息配置到xml当中

<bean id="userService" class="com. itheima.service.impl.UserServiceImpl"></bean> 

4. 编写测试代码,创建BeanFactory,加载配置文件,获取UserService实例对象。

//创建工厂对象(后面会被applicationContext替代)
DefaultListableBeanFactory BeanFactory = new DefaultListableBeanFactory();
//创建一个读取器(XML文件)
XmlBeanDefinitionReader Reader = new XmlBeanDefinitionReader(BeanFactory);
//读取配置文件给工厂
Reader.loadBeanDefinitions("beans.xml");
//根据id获取Bean实例对象
UserService userService = (UserService)BeanFactory.getBean("UserService");
  • 实现依赖注入
  1. 创建UserDao接口和实现的UserDaoImpl接口实现类
  2. 将UserServiceImpl当中添加一个setUserDao的方法
public class UserServiceImpl implements UserService {
    public void setUserDao(UserDao userDao){
        System.out.println("BeanFactory调用方法获取userDao设置到此处"+userDao);
    }
} 
  1. 添加bean.xml配置信息,添加bean中嵌入<property>配置注入
<bean id="UserService" class="com.huanglei.service.Impl.UserServiceImpl">
   <property name="userDao" ref="UserDao"/>
</bean>
<bean id="UserDao" class="com.huanglei.Dao.Impl.UserDaoImpl"></bean> 
  1. 创建测试方法,当获取到UserService时就自动进行UserDao的依赖注入
//创建工厂对象
DefaultListableBeanFactory BeanFactory = new DefaultListableBeanFactory();
//创建一个读取器(XML文件)
XmlBeanDefinitionReader Reader = new XmlBeanDefinitionReader(BeanFactory);
//读取配置文件给工厂
Reader.loadBeanDefinitions("beans.xml");
//根据id获取Bean实例对象
UserService userService = (UserService)BeanFactory.getBean("UserService"); 

1.7 ApplicationContext快速入门

ApplicationContext 称为Spring容器,内部封装了BeanFactory,比BeanFactory功能更丰富更强大,使用ApplicationContext进行开发时,xml配置文件的名称习惯写成applicationContext.xml

利用ApplicationContext创建IoC容器的基本操作:

//创建ApplicationContext,加载配置文件,实例化容器
ApplicationContext applicationContext = new ClassPathxmlApplicationContext("applicationContext.xml");
//根据beanName获得容器中的Bean实例
UserService userService = (UserService) applicationContext.getBean("UserService");
System.out.println(userService) ;

1.8 BeanFactory和ApplicationContext之间的关系

  1. BeanFactory是Spring的早期接口,称为Spring的Bean工厂,
    ApplicationContext是后期更高级接口,称之为Spring容器;
  2. ApplicationContext在BeanFactory基础上对功能进行了扩展,例如:监听功能、国际化功能等。
  3. BeanFactory的API更偏向底层,
    ApplicationContext的API大多数是对这些底层API的封装;
  4. Bean创建的主要逻辑和功能都被封装在BeanFactory中,ApplicationContext不仅继承了BeanFactory,而且ApplicationContext内部还维护着BeanFactory的引用,所以,ApplicationContext与BeanFactory既有继承关系,又有融合关系。
  5. Bean的初始化时机不同,原始BeanFactory是在首次调用getBean时才进行Bean的创建,
    ApplicationContext则是配置文件加载,容器一创建就将Bean都实例化并初始化好。

ApplicationContext除了继承了BeanFactory外,还继承了ApplicationEventPublisher(事件发布器)、ResouresPatternResolver(资源解析器)、MessageSource(消息资源)等。但是ApplicationContext的核心功能还是BeanFactory。

Spring学习笔记(1),spring,学习,笔记
Spring学习笔记(1),spring,学习,笔记

1.9 BeanFactory和ApplicationContext的继承体系

  • BeanFactory的继承体系:

BeanFactory是核心接口,项目运行过程中肯定有具体实现参与,这个具体实现就是DefaultListableBeanFactory,而ApplicationContext内部维护的Beanfactory的实现类也是它

Spring学习笔记(1),spring,学习,笔记

  • ApplicationContext的继承体系

只在Spring基础环境下,即只导入spring-context坐标时,此时ApplicationContext的继承体系

Spring学习笔记(1),spring,学习,笔记
只在Spring基础环境下,常用的三个ApplicationContext作用如下:

实现类 功能描述
ClassPathXmlApplicationContext 加载类路径下的xml配置的ApplicationContext
FileSystemXmlApplicationContext 加载磁盘路径下的xml配置的ApplicationContext
AnnotationConfigApplicationContext 加载注解配置类的ApplicationContext

如果Spring基础环境中加入了其他组件解决方案,如web层解决方案,即导入spring-web坐标,此时ApplicationContext的继承体系

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.3.7</version>
</dependency>

只在Spring的Web环境下,常用的两个ApplicationContext作用如下:

实现类 功能描述
XmlWebApplicationContext web环境下,加载类路径下的xml配置的ApplicationContext
AnnotationConfigWebApplicationContext web环境下,加载磁盘路径下的xml配置的ApplicationContext

二、基于XML方式的Bean配置

2.1 常见的Bean配置

Xml配置方式 功能描述
<bean id=“” class=“”> Bean的id和全限定名配置
<bean name=“”> 通过name设置Bean的别名,通过别名也能直接获取到Bean实例
<bean scope=“”> Bean的作用范围, BeanFactory作为容器时取值singleton和prototype
<bean lazy-init=“”> Bean的实例化时机,是否延迟加载。BeanFactory作为容器时无效
<bean init-method=“”> Bean实例化后自动执行的初始化方法,method指定方法名
<bean destroy-method=“”> Bean实例销毁前的方法,method指定方法名
<bean autowire=“byType”> 设置自动注入模式,常用的有按照类型byType,按照名字byName
<bean factory-bean=“” factory-method=“”/> 指定哪个工厂Bean的哪个方法完成Bean的创建

2.2 beanName的别名配置

Bean的基础配置

例如:配置UserDaolmpl由Spring容器负责管理

<bean id="userDao" class="com.itheima.dao .impl.UserDaoImp! " />

此时存储到Spring容器(singleObjects单例池)中的Bean的beanName是userDao,值是UserDaolmpl对象,可以根据beanName获取Bean实例

applicationContext.getBean("userDao");

如果不配置id,则Spring会把当前Bean实例的全限定名作为beanName

applicationContext.getBean("com.itheima.dao.impl.UserDaoImpl"); 

Bean的别名配置

可以为当前Bean指定多个别名,根据别名也可以获得Bean对象

<bean id="userDao" name="aaa,bbb" class="com.itheima.dao.impl.UserDaoImp1" />

此时多个名称都可以获得UserDaolmpl实例对象

applicationContext.getBean("userDao");
applicationContext.getBean("aaa");
applicationContext.getBean("bbb"); 

总结

  1. 如果有id ,那么beanName就是指的是qiid,但是也可以用name别名的方式进行调用
  2. 如果没有id,那么就可以调用Bean实例的权限名name进行调用BeanName

2.3、Bean的作用范围scope配置

默认情况下,单纯的Spring环境Bean的作用范围有两个: SingletonPrototype

  • singleton:单例,默认值,Spring容器创建的时候,就会进行Bean的实例化,并存储到容器内部的单例池中,每次getBean时都是从单例池中获取相同的Bean实例;
  • prototype:原型,Spring容器初始化时不会创建Bean实例当调用getBean时才会实例化Bean,每次getBean都会创建一个新的Bean实例。

2.4、Bean的延迟加载

  • lazy-init设置为
    • true时为延迟加载,也就是当Spring容器创建的时候,不会立即创建Bean实例,等待用到时在创建Bean实例并存储到单例池中去,后续在使用该Bean直接从单例池获取即可,本质上该Bean还是单例的
    • false时Spring容器创建的时候,就会进行Bean的实例化,并存储到容器内部的单例池中,每次getBean时都是从单例池中获取相同的Bean实例;
<bean id="userDao" class=" com.itheima.dao.impl.UserDaoImpl" lazy-init="true"/> 

2.5、Bean的初始化方法和销毁方法

Bean在被实例化后,可以执行指定的初始化方法完成一些初始化的操作,Bean在销毁之前也可以执行指定的销毁方法完成一些操作,初始化方法名称和销毁方法名称通过

<bean id="userDao" class=" com.itheima.dao .impl.UserDaoImpl" init-method="init" destroy-method="destroy" />
public class UserDaoImpl implements UserDao {
	public UserDaoImpl() {	System.out.println("UserDaoImpl创建了...");}
	public void init(){	System.out.println("初始化方法...");}
	public void destroy(){ system.out.println("销毁方法...");}
}

2.6、InitializingBean接口方式

扩展:除此之外,我们还可以通过实现InitializingBean接口,完成一些Bean的初始化操作,如下:

public class UserDaoImpl implements UserDao,InitializingBean {
	public UserDaoImpl(){System.out.println("UserDaoImpl创建了...");}
	public void init(){System.out.println("初始化方法...");}
	public void destroy(){System.out.println("销毁方法...");}
	//执行时机早于init-method配置的方法
	public void afterPropertiesSet() throws Exception {
		System.out.println("InitializingBean...");
	}
} 

综上所述,我们现在有两种初始化操作:

  1. init-method=“init” destroy-method=“destroy”
  2. 调用接口InitializingBean实现当中的方法

调用顺序: 接口方法InitializingBean > init-method的方法

2.7、实例化Bean的方式-构造方法方式

Bean的实例化配置

  • Spring的实例化方式主要如下两种:
    • 构造方式实例化: 底层通过构造方法对Bean进行实例化
    • 工厂方式实例化: 底层通过调用自定义的工厂方法对Bean进行实例化

构造方式实例化Bean又分为无参构造方法实例化和有参构造方法实例化,Spring中配置的<bean>几乎都是无参构造该方式 。下面讲解有参构造方法实例化Bean

//有参构造方法
public UserDaoImpl (String name) {} 

有参构造在实例化Bean时,需要参数的注入,通过<constructor-arg>标签,嵌入在标签内部提供构造参数,如下:

<bean id="userDao" class="com.itheima.dao .impl.UserDaoImpl">
	<constructor-arg name="name" value="haohao" />
</bean> 

<constructor-arg><property> 的区别

  • <constructor-arg> <property>都是用来注入依赖的标签,但是它们的使用场景不同。
    • <constructor-arg> 用于构造函数注入,即在创建对象时通过构造函数传入依赖。它可以指定参数的类型、索引或者参数名,用于匹配构造函数的参数列表。
    • <property> 用于属性注入,即在创建对象后通过 setter 方法设置依赖。它可以指定属性名或者索引,用于匹配对象的 setter 方法。

因此,如果一个类只有一个构造函数,并且这个构造函数的参数都是必需的,那么可以使用 <constructor-arg> 进行注入;如果一个类有多个构造函数,或者有一些可选的依赖,那么可以使用<property>进行注入。

2.7 工厂方式实列化Bean

工厂方式实例化Bean,又分为如下三种:

  • 静态工厂方法实例化Bean
  • 实例工厂方法实例化Bean
  • 实现FactoryBean规范延迟实例化Bean

2.7.1 、静态工厂方法方式

public class FactoryDemo1 {
    public static UserService CreateUserService(){
        return new UserServiceImpl();
    }
} 
<bean id="FactoryDemo1" class="com.huanglei.Factory.FactoryDemo1" factory-method="CreateUserService"></bean> 

优点:
1. 可以在创建对象之前执行一些其他的逻辑操作
2. 可以生成一些jar包或者工具类使用静态方法创建的对象

2.7.2、实例工厂方法方式

使用该工厂方法的优点:

1. 可以执行一些创建对象之前其他的逻辑操作
2. 可以生成一些其他工具类或jar包通过方法来创造的对象

public class FactoryDemo2 {
    public  UserService CreateUserService(){
        return new UserServiceImpl();
    }
} 
<!--配置实例工厂方法-->
<!--先设置工厂对象-->
<bean id="factoryDemo2" class="com.huanglei.Factory.FactoryDemo2"></bean>
<!--在设置工厂方法-->
<bean id="factoryUser" factory-bean="factoryDemo2" factory-method="CreateUserService"></bean> 

2.7.3、有参数的静态工厂和实例工厂方法

<bean id="factoryUser" factory-bean="factoryDemo2" factory-method="CreateUserService">
    <constructor-arg name="name" value="zhangsan"/>
</bean> 

2.7.4、实现FactoryBean规范延迟实例化Bean

使工厂类继承FactoryBean<UserDao>
通过getObject()方法返回对象

public class FactoryDemo3 implements FactoryBean<UserDao> { 
    @Override
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }
    @Override
    public Class<?> getObjectType() {
        return null;
    }
} 

这个方法有延迟性,只有使用getBean方法调用时才会将Bean数据加载到FactoryBean当中

2.8 注入问题

  1. Bean的依赖注入
注入方式 配置方式
通过Bean的set方法注入 <property name="userDao" ref="userDao" /><property name="userDao" value="haohao"/>
通过构造Bean的方法进行注入 <constructor-arg name="name" ref="userDao"/><constructor-arg name="name" value="haohao"/>

ref时调用其他的bean当中的id,value调用的是普通的值,一般在setter当中利用property方法注入值,

  1. 依赖注入类型
  • 普通数据类型,例如: String、int、 boolean等,通过value属性指定
  • 引用数据类型,例如: UserDaolmpl、DataSource等,通过ref属性指定。
  • 集合数据类型,例如: List、Map、Properties等。

注:property和constructor-arg的name属性和参数的名字必须要一样

public class UserDaoImpl implements UserDao {
    //注入一个List集合
    private List<String> list;
    public void setList(List<String> list) {
        this.list = list;
    }
    //注入一个字符串类型的Set集合
    private Set<String> userSet;
    public void setUserSet(Set<String> userSet) {
        this.userSet = userSet;
    }
    //注入一个UserDao类的Set集合
    private Set<UserDao> userDaoSet;
    public void setUserDaoSet(Set<UserDao> userDaoSet) {
        this.userDaoSet = userDaoSet;
    }
    //注入一个map集合
    private Map<String,UserDao> map;
    public void setMap(Map<String,UserDao> map) {
        this.map = map;
    }
    //注入Properties
    private Properties properties;
    public void setProperties(Properties properties){
        this.properties = properties;
    }
    public void show(){
        System.out.println(list);
        System.out.println(userSet);
        System.out.println(userDaoSet);
        System.out.println(map);
        System.out.println(properties);
    }
}

<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">

    <bean id="userDao" class="com.huanglei.Dao.Impl.UserDaoImpl">
        <!--配置注入一个List类型的集合-->
        <property name="list">
            <list>
                <value>aaa</value>
                <value>sss</value>
            </list>
        </property>
        <!--配置注入一个Set集合-->
        <property name="userSet">
            <set>
                <value>asdsa</value>
                <value>11111</value>
                <value>22222</value>
                <value>33333</value>
            </set>
        </property>
        <!--配置注入一个UserDao类的Set集合-->
        <property name="userDaoSet">
            <set>
                <ref bean="userDao1"></ref>
                <ref bean="userDao2"></ref>
                <ref bean="userDao3"></ref>
                <ref bean="userDao4"></ref>
            </set>
        </property>
        <!--配置注入一个map集合-->
        <property name="map">
            <map>
                <entry key="m1" value-ref="userDao1"></entry>
                <entry key="m2" value-ref="userDao2"></entry>
                <entry key="m3" value-ref="userDao3"></entry>
                <entry key="m4" value-ref="userDao4"></entry>
            </map>
        </property>
        <!--配置一个properties(键值都是string的键值对)-->
        <property name="properties">
            <props>
                <prop key="p1">p111</prop>
                <prop key="p2">p222</prop>
                <prop key="p3">p333</prop>
                <prop key="p4">p444</prop>
            </props>
        </property>
    </bean>

    <bean id="userDao1" class="com.huanglei.Dao.Impl.UserDaoImpl"></bean>
    <bean id="userDao2" class="com.huanglei.Dao.Impl.UserDaoImpl"></bean>
    <bean id="userDao3" class="com.huanglei.Dao.Impl.UserDaoImpl"></bean>
    <bean id="userDao4" class="com.huanglei.Dao.Impl.UserDaoImpl"></bean>
</beans>

2.9 自动装配

扩展:自动装配方式

如果被注入的属性类型是Bean引用的话,那么可以在<bean>标签中使用autowire属性去配置自动注入方式,属
性值有两个:

  • byName:通过属性名自动装配,即去匹配 setXxx 与id=“xxx” (name=“xxx”)是否一致;
  • byType:通过Bean的类型从容器中匹配,匹配出多个相同Bean类型时,报错。
private UserService userService;
public void setUserService(UserService userService){
    this.userService  = userService;
}
<bean id="userDao" class="com.huanglei.Dao.Impl.UserDaoImpl" autowire="byName"></bean>
<bean id="userService" class="com.huanglei.service.Impl.UserServiceImpl"></bean> 

2.10 命名空间

Spring的xml标签大体上分为两类,一种是默认标签,一种是自定义标签

  • 默认标签:就是不用额外导入其他命名空间约束的标签,例如<bean>标签
  • 自定义标签:就是需要额外引入其他命名空间约束,并通过前缀引用的标签,例如<context:property-placeholder/>标签

Spring的默认标签用到的是Spring的默认命名空间

<?xml version="1.0"encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
		xmlns:xsi="http: //www.w3.org/2001/xMschema-instance"
		xsi:schemalocation="http: //www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans> 

该命名空间约束下的默认标签如下:

标签 作用
<beans> 一般作为xml配置根标签,其他标签都是该标签的子标
<bean> Bean的配置标签,上面已经详解了,此处不再阐述
<import> 外部资源导入标签
<alias> 指定Bean的别名标签,使用较少

2.10.1 profile属性切换环境

<beans>标签,除了经常用的做为根标签外,还可以嵌套在根标签内,使用profile属性切换开发环境

<!--配置测试环境下,需要加载的Bean实例,下面是写test环境下-->
<beans profile="test">

</beans>

<!--配置开发环境下,需要加载的Bean实例,下面是写dev环境下-->
<beans profile="dev">

</beans>

可以使用以下两种方式指定被激活的环境:

  • 使用命令行动态参数,虚拟机参数位置加载 -Dspring.profiles.active=test
  • 使用代码的方式设置环境变量 System.setProperty("spring.profiles.active","test")

2.10.2、import标签

<import>标签,用于导入其他配置文件,项目变大后,就会导致一个配置文件内容过多,可以将一个配置文件根据业务某块进行拆分,拆分后,最终通过<import>标签导入到一个主配置文件中,项目加载主配置文件就连同<import>导入的文件一并加载了

<!--导入用户模块配置文件-->
<import resource="classpath:UserModuleApplicationcontext.xml"/>
<!--导入商品模块配置文件-->
<import resource="classpath:ProductModuleApplicationcontext.xml"/>
<!--导入properties配置文件-->
<import resource="classpath:jdbc.properties"/>

2.10.3、alias标签

<alias>标签是为某个Bean添加别名,与在<bean>标签上使用name属性添加别名的方式一样,我们为UserServicelmpl指定四个别名: aaa、bbb、xxx、yyy

<!--配置UserService-->
<bean id="userService" name="aaa,bbb" class="com.itheima.service.imp1.UserserviceImp1">
	<property name="userDao" ref="userDao"/>
</bean>
<!--指定别名-->
<alias name="userservice" alias="xxx"/>
<alias name="userservice" alias="yyy"/> 

2.9.1、自定义命名空间的使用步骤

Spring的自定义标签需要引入外部的命名空间,并为外部的命名空间指定前缀,使用<前缀:标签>形式的标签,称之为自定义标签,自定义标签的解析流程也是Spring xml扩展点方式之一文章来源地址https://www.toymoban.com/news/detail-724868.html

<!--默认标签-->
<bean id="userDao" class="com.itheima. dao .imp1.userDaoImpl" />
<!--自定义标签-->
<context:property-placeholder/>
<mvc:annotation-driven/>
<dubbo:application name="application"/>
  • 步骤:
    • 引入坐标,引入jar包
    • 找命名空间xmlns和xsi
    • 通过前缀来引入自定义标签

三、Spring中getBean常用的API

方法定义 返回值和参数
Object getBean (String beanName) 根据beanName从容器中获取Bean实例,要求容器中Bean唯一,返回值为Object,需要强转
T getBean (Class type) 根据Class类型从容器中获取Bean实例,要求容器中Bean类型唯一,返回值为Class类型实例,无需强转
T getBean (String beanName,Class type) 根据beanName从容器中获得Bean实例,返回值为Class类型实例,无需强转
//根据beanName获取容器中的Bean实例,需要手动强转
UserService userService = (UserService)applicationContext.getBean("userService");
//根据Bean类型去容器中匹配对应的Bean实例,如存在多个匹配Bean则报错
UserService userService2 = applicationContext.getBean(UserService.class);
//根据beanName获取容器中的Bean实例,指定Bean的Type类型
UserService userService3 = applicationContext.getBean("userService",UserService.class) ;

到了这里,关于Spring学习笔记(1)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Spring5 学习笔记

    前置知识: 掌握Java基础知识(特别是反射) 掌握Java注解 掌握XML 掌握Maven 简化企业开发的复杂性 Spring理念:使现有的技术更加容易使用,本身是一个大杂烩,整合了现有的技术框架。 SSH:Struct2 + Spring + Hibernate SSM:Spring MVC + Spring + MyBatis 官网 : http://spring.io/ 官方下载地址

    2024年02月07日
    浏览(53)
  • Spring学习笔记(1)

    问题一: 层与层之前联系在一起,耦合性高(接口与实现类相互联系) 解决方法: Spring提供了第三方来自动加载对象,不用自己手动new出对象,第三方自动提供Bean对象 问题二:通用的事务功能耦合在业务代码中,通用的日志功能耦合在业务代码中 通用的事务功能指的是一

    2024年02月07日
    浏览(37)
  • spring学习笔记八

    1、BookDao接口和实现类 2、配置文件 3、使用方法 4、总结 Array使用array和value节点注入 List使用list和value节点注入 Set使用set和value节点注入 Map使用map和entry节点中的key和value属性注入 Properties使用props中prop节点的key属性和内容注入

    2024年02月15日
    浏览(32)
  • spring学习笔记三

    1.1、OrderDao接口与实现类 1.2、OrderFactory类 1.3、spring配置applicationContext.xml 1.4、使用 1.5、总结 在xml中配置class的工厂类,factory-method指定工厂实例方法 2.1、UserDao接口和实现类 2.2、UserDaoFactory类 2.3、配置applicationContext.xml 2.4、使用 2.5、总结 设置userFactory的Bean 设置userDao的Bean,配

    2024年02月15日
    浏览(35)
  • spring学习笔记七

    1.1、BookDao接口和实现类 1.2、BookService接口和实现类 1.3、配置文件 1.4、使用方法 1.5、总结 在配置文件中添加autowire属性为byType spring会按照BookDao类型找到对应的Bean实现注入

    2024年02月16日
    浏览(33)
  • Spring -学习笔记

    概念: Spring 是一个开源的企业级应用程序开发框架,它为 Java 应用程序提供了全面的基础设施支持和丰富的功能模块。Spring 的目标是简化 Java 开发,提高开发效率、代码质量和可维护性。 Aim: 解决企业级应用开发的复杂性而存在; 核心: Spring的核心是提供一个容器。 这

    2024年02月11日
    浏览(32)
  • 学习笔记-Spring事务

    学习的文章 小姐姐非要问我:spring编程式事务是啥? (qq.com) 一文搞懂什么是事务 - 知乎 (zhihu.com) 阿里3面:Spring声明式事务连环炮,让我措手不及。。 (qq.com) 带你读懂Spring 事务——事务的传播机制 - 知乎 (zhihu.com) spring 事务失效的 12 种场景_事务什么时候失效_hanjq_code的博客

    2024年02月06日
    浏览(39)
  • Spring Data JPA 学习笔记

    Spring Data JPA: Spring Data JPA 的技术特点: @Entity 标注是一个实体类,实体类中的每一个属性都对应表中的一列。 @Table(name = “User”) 这个注解用于指定实体类对应的数据库表名。(但首字母会小写) @Data:这个注解是Lombok库提供的,用于自动生成实体类的getter和setter方法、构造函

    2024年04月09日
    浏览(54)
  • Spring5学习笔记--Maven

    本文主要内容 理解并实现分模块开发 能够使用聚合工程快速构建项目 能够使用继承简化项目配置 能够根据需求配置生成、开发、测试环境,并在各个环境间切换运行 了解Maven的私服 clean清理阶段 清理工作 pre-clean 执行一些需要在clwan之前完成的工作 clean 移除所有上一次构建

    2024年02月16日
    浏览(40)
  • Spring学习笔记(四)AOP介绍

            AOP的全称是Aspect Oriented Programming,即 面向切面编程 。和OOP(面向对象编程)不同,AOP主张将程序中相同的业务逻辑进行 横向隔离 ,并将重复的业务逻辑抽取到一个独立的模块中,以达到 提高程序可重用性和开发效率的目的 。                在传统的业务处理代

    2024年02月21日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包