spring学习笔记

最新推荐文章于 2025-06-03 21:06:54 发布

FS370

最新推荐文章于 2025-06-03 21:06:54 发布

阅读量144

点赞数

分类专栏： java 文章标签： spring java ioc 依赖注入

本文链接：https://blog.csdn.net/weixin_43587190/article/details/117371391

版权

java 专栏收录该内容

7 篇文章

订阅专栏

Spring相关API

体系结构
Spring的API体系异常庞大，我们现在只关注两个BeanFactory和ApplicationContext

BeanFactory

BeanFactory是IOC的核心接口，他定义了IOC的基本功能。

ApplicationContext

ApplicationContext代表应用上下文对象，可以获得springIOC容器中的Bean对象

ApplicationContext和 BeanFactory 的区别？

//使用ClassPathXmlApplicationContext 获取spring上下文对象，借助上下文对象可以获取到IOC容器中的bean对象，它再加载配置文件的同时就创建了bean对象到容器中
 ApplicationContext applicationContext = new   ClassPathXmlApplicationContext("applicationContext.xml");

//使用上下文对象从IOC容器中获取bean
 IUserDao userDao = (IUserDao) applicationContext .getBean("userDao");


 //核心接口  这一步不会创建bean对象  存到容器中的
BeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

//getBean的时候 才正真的创建bean对象
IUserDao userDao = (IUserDao) xmlBeanFactory.getBean("userDao");

从上面代码来说
ApplicationContext 在加载核心配置文件的时候就去创建了bean对象到容器
BeanFactory 是真正在getBean的时候才去创建bean对象

ApplicationContext常用的实现类

ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件推荐使用这种。
FileSystemXmlApplicationContext 它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext 当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

常用方法

// 根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。 
Object getBean(String name);

//根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。
<T> T getBean(Class<T> requiredType); 

//根据Bean的id和类型获得Bean实例，解决容器中相同类型Bean有多个情况。 
<T> T getBean(String name,Class<T> requiredType);

Spring配置文件

Bean标签的基本配置

 <!--
 	bean标签：在spring配置文件中配置 userDaoImpl
    id:Bean实例在spring容器中的唯一标识，使用过程中根据这个id才能在spring中找到我们需要的Bean
    class:Bean的全限定名（spring底层采用反射来生成该类的实例，所以必须要放该类的全限定名）
    -->
<bean id = "唯一标识" class="类的全路径名"></bean>
<!--
	默认情况下它是调用类中的无参构造函数进行对象创建，如果没有无参构造函数则不能创建对象
-->

Bean标签的范围配置

  <bean id="" class="" scope="作用范围"></bean>

scope属性指对象的作用范围，取值如下：

取值范围	说明
singleton	默认值，单例的
prototype	多例的
request	WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中
session	WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中
global session	WEB项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession 相当于 session

 	/**
     * <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl" scope="singleton" ></bean>
     * 测试 scope为singleton的情况下 bean的创建情况
     */
    @Test
    public void test03(){

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        //userDao1
        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao1);

        //userDao2
        IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao2);
    }

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


    /**
     * <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl" scope="prototype" ></bean>
     * 测试 scope为prototype的情况下 bean的创建情况
     */
    @Test
    public void test04(){

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        //userDao1
        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao1);

        //userDao2
        IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao2);
    }

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

1.当scope的取值为singleton时
			Bean的实例化个数：1个
			Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean的实例
			Bean的生命周期：
				对象创建：当容器加载，创建容器时，对象就被加载了
				对象运行：只要容器在，对象一直活着
				对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2.当scope的取值为prototype时
			Bean的实例化个数：多个
			Bean的实例化时机：当调用getBean()方法时实例化Bean
			Bean的生命周期：
				对象创建：当使用对象时，对象就被加载了
				对象运行：只要对象在使用中，对象一直活着
				对象销毁：当对象长时间不用时，被Java的垃圾回收器回收

bean声明周期配置

bean id="" class="" scope="" init-method="" destroy-method=""></bean> 

* init-method：指定类中的初始化方法名称 

* destroy-method：指定类中销毁方法名称

Bean实例化三种方式

无参构造方法实例化
工厂静态方法实例化
工厂普通方法实例化

无参构造方法实例化

它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>

工厂静态方法实例化

依赖的jar包中有个A类，A类中有个静态方法m1，m1方法的返回值是一个B对象。如果我们频繁使用B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

public class StaticFactoryBean { 

	public static UserDao createUserDao(){ 
		return new UserDaoImpl(); 
	} 
}

<bean id="userDao" class="com.lagou.factory.StaticFactoryBean" factory-method="createUserDao" />

工厂普通方法实例化

依赖的jar包中有个A类，A类中有个普通方法m1，m1方法的返回值是一个B对象。如果我们频繁使用B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

public class DynamicFactoryBean{ 

	public UserDao createUserDao(){ 
		return new UserDaoImpl(); 
	} 
}

<bean id="dynamicFactoryBean" class="com.lagou.factory.DynamicFactoryBean"/> 
<bean id="userDao" factory-bean="dynamicFactoryBean" factory-method="createUserDao"/>

Bean依赖注入概述

依赖注入 DI（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。
在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系但不会消除。例如：业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。

Bean依赖注入方式

构造方法

public class UserServiceImpl implements UserService { 

private UserDao userDao; 

public UserServiceImpl(UserDao userDao) { 
	this.userDao = userDao; 
}

@Override public void save() { 
		userDao.save(); 
	} 
}

配置Spring容器调用有参构造时进行注入

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl"> 
<!--<	<constructor-arg index="0" type="com.lagou.dao.UserDao" ref="userDao"/> - ->
	<constructor-arg name="userDao" ref="userDao"/> </bean>

set方法

public class UserServiceImpl implements UserService { 

private UserDao userDao; 

public void setUserDao(UserDao userDao) { 
	this.userDao = userDao;
}

@Override public void save() { 
		userDao.save(); 
	} 
}

配置Spring容器调用set方法进行注入

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl"> 
	<property name="userDao" ref="userDao"/>

P命名空间注入

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件中，如下：
首先，需要引入P命名空间：

xmlns:p="http://www.springframework.org/schema/p"

其次，需要修改注入方式：

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

Bean依赖注入的数据类型

注入数据的三种数据类型
1. 普通数据类型
2. 引用数据类型
3. 集合数据类型

public class User { 
	private String username; 
	private String age; 
	
	public void setUsername(String username) { 
		this.username = username; 
	}
	
	public void setAge(String age) { 
		this.age = age; 
	} 
}

<bean id="user" class="com.lagou.domain.User"> 
	<property name="username" value="jack"/> 
	<property name="age" value="18"/> 
</bean>

注入集合数据类型
1）List集合注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
    private List<Object> list;
    
    public void setList(List<Object> list) {
        this.list = list;
    }
 }

    <!--进行list集合数据类型的注入-->
        <property name="list">
            <list>
                <value>aaa</value>
                <ref bean="user"></ref>
            </list>
        </property>

2）Set集合注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
    private Set<Object> set;
    
     public void setSet(Set<Object> set) {
        this.set = set;
    }
 }

    <!--进行set集合数据类型的注入-->
        <property name="set">
            <set>
                <value>bbb</value>
                <ref bean="user"></ref>
            </set>
        </property>

3）Array数组注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
   private Object[] array;
    
      public void setArray(Object[] array) {
        this.array = array;
    }
}

   <!--进行array数组数据类型的注入-->
        <property name="array">
            <array>
                <value>ccc</value>
                <ref bean="user"></ref>
            </array>
        </property>

4）Map集合注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
 private Map<String,Object> map;
    
   public void setMap(Map<String, Object> map) {
        this.map = map;
    }
}

    <!--进行map集合数据类型的注入-->
        <property name="map">
            <map>
                <entry key="k1" value="ddd"></entry>
                <entry key="k2" value-ref="user"></entry>
            </map>
        </property>

5）Properties配置注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
private Properties properties;
    
   public void setProperties(Properties properties) {
        this.properties = properties;
    }
}

    <!--进行map集合数据类型的注入-->
        <!--进行properties数据类型的注入-->
        <property name="properties">
            <props>
                <prop key="k1">v1</prop>
                <prop key="k2">v2</prop>
                <prop key="k3">v3</prop>
            </props>
        </property>

配置文件模块化

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，也就是所谓的配置文件模块化。

1）并列的多个配置文件

ApplicationContext act = new ClassPathXmlApplicationContext("beans1.xml","beans2.xml","...");

2）主从配置文件

<import resource="applicationContext-xxx.xml"/>

注意：

同一个xml中不能出现相同名称的bean,如果出现会报错
多个xml如果出现相同名称的bean，不会报错，但是后加载的会覆盖前加载的bean

DbUtils是什么？

DbUtils是Apache的一款用于简化Dao代码的工具类，它底层封装了JDBC技术。

核心对象

QueryRunner queryRunner = new QueryRunner(DataSource dataSource);

核心方法

//执行增、删、改语句
int update(); 

//执行查询语句 ResultSetHandler<T> 这是一个接口，主要作用是将数据库返回的记录封装到实体对象
T query();

抽取jdbc配置文件
applicationContext.xml加载jdbc.properties配置文件获得连接信息。
首先，需要引入context命名空间和约束路径：

* 命名空间： 
* xmlns:context="http://www.springframework.org/schema/context" 

* 约束路径： 
* http://www.springframework.org/schema/context 
* http://www.springframework.org/schema/context/spring-context.xsd

context:property-placeholder

<context:property-placeholder location="classpath:jdbc.properties"

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> 
	<property name="driverClassName" value="${jdbc.driver}"></property> 
	<property name="url" value="${jdbc.url}"></property> 
	<property name="username" value="${jdbc.username}"></property> 
	<property name="password" value="${jdbc.password}"></property>
 </bean>
/>

Spring注解开发

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。
Spring常用注解主要是替代的配置

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	结合@Autowired一起使用,根据名称进行依赖注入
@Resource	相当于@Autowired+@Qualifier，按照名称进行注入
@Value	注入普通属性
@Scope	标注Bean的作用范围

说明：
JDK11以后完全移除了javax扩展导致不能使用@resource注解

需要maven引入依赖 
<dependency> 
	<groupId>javax.annotation</groupId> 
	<artifactId>javax.annotation-api</artifactId> 
	<version>1.3.2</version> 
</dependency>

注意
使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。

<!--注解的组件扫描--> <context:component-scan base-package="com.lagou"></context:component-scan>

1）Bean实例化（IOC）
使用@Compont或@Repository标识UserDaoImpl需要Spring进行实例化。

// @Component(value = "userDao") 
@Repository // 如果没有写value属性值，Bean的id为：类名首字母小写 
public class UserDaoImpl implements UserDao { 
}

2）属性依赖注入（DI）
使用@Autowired或者@Autowired+@Qulifier或者@Resource进行userDao的注入

@Autowired private UserDao userDao; 

// <property name="userDao" ref="userDaoImpl"/> 
// @Autowired 
// @Qualifier("userDaoImpl") 
// @Resource(name = "userDaoImpl")

3）@Value
使用@Value进行字符串的注入，结合SPEL表达式获得配置参数

@Value("注入普通数据") 
private String str; 

@Value("${jdbc.driver}") 
private String driver;

4）@Scope
使用@Scope标注Bean的范围

@Service 
@Scope("singleton") 
public class UserServiceImpl implements UserService {
}

使用上面的注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下：

* 非自定义的Bean的配置：<bean>

* 加载properties文件的配置：<context:property-placeholder>

* 组件扫描的配置：<context:component-scan>

* 引入其他文件：<import>

注解	说明
@Configuration	用于指定当前类是一个Spring 配置类，当创建容器时会从该类上加载注解
@Bean	使用在方法上，标注将该方法的返回值存储到 Spring 容器中
@PropertySource	用于加载 properties 文件中的配置
@ComponentScan	用于指定 Spring 在初始化容器时要扫描的包
@Import	用于导入其他配置类

Spring核心配置类

@Configuration 
@ComponentScan("com.lagou") 
@Import(DataSourceConfig.class) 
public class SpringConfig { 

	@Bean("queryRunner") 
	public QueryRunner getQueryRunner(@Autowired DataSource dataSource) { 
		return new QueryRunner(dataSource); 
		} 
}

数据库配置信息类

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfig {
@Value("${jdbc.driver}") 
private String driver; 

@Value("${jdbc.url}") 
private String url; 

@Value("${jdbc.username}") 
private String username; 

@Value("${jdbc.password}") 
private String password;

@Bean("dataSource") 
public DataSource getDataSource() { 
	DruidDataSource dataSource = new DruidDataSource(); 
	dataSource.setDriverClassName(driver);
	dataSource.setUrl(url); 
	dataSource.setUsername(username); 
	dataSource.setPassword(password); 
	return dataSource;
} 
}

Spring整合Junit

普通Junit测试问题
在普通的测试类中，需要开发者手动加载配置文件并创建Spring容器，然后通过Spring相关API获得Bean实例；如果不这么做，那么无法从容器中获得对象。

  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        //userDao1
        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao1);

我们可以让SpringJunit负责创建Spring容器来简化这个操作，开发者可以直接在测试类注入Bean实
例；但是需要将配置文件的名称告诉它。

导入spring集成Junit的坐标
使用@Runwith注解替换原来的运行器
使用@ContextConfiguration指定配置文件或配置类
使用@Autowired注入需要测试的对象
创建测试方法进行测试

2）使用@Runwith注解替换原来的运行器

@RunWith(SpringJUnit4ClassRunner.class) 
public class SpringJunitTest { }

3）使用@ContextConfiguration指定配置文件或配置类

@RunWith(SpringJUnit4ClassRunner.class) 
//@ContextConfiguration(value = {"classpath:applicationContext.xml"}) 加载spring 核心配置文件 
@ContextConfiguration(classes = {SpringConfig.class}) // 加载spring核心配置类 
public class SpringJunitTest { }