Spring -- 基础

添加依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
</dependencies>

在applicatonContext.xml添加各种bean
注意事项：bean定义时id属性在同一个上下文中(配置文件)不能重复

<?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.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <!--bean标签标示配置bean
    	id属性标示给bean起名字
    	class属性表示给bean定义类型
	-->
	<bean id="bookDao" class="com.spring_demo.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.spring_demo.service.impl.BookServiceImpl"/>

</beans>

从容器中获取bean

public class App {
    public static void main(String[] args) {
        //获取IOC容器
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

实现注入：在BookServiceImpl中引用了BookDao对象，不直接new 一个BookDao接口的实现类对象，而是通过Spring依赖注入的方式

// BookServiceImpl.java
public class BookServiceImpl implements BookService {
    //删除业务层中使用new的方式创建的dao对象
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

<?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.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--bean标签标示配置bean
    	id属性标示给bean起名字
    	class属性表示给bean定义类型
	-->
    <bean id="bookDao" class="com.spring_demo.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.spring_demo.service.impl.BookServiceImpl">
        <!--配置server与dao的关系-->
        <!--property标签表示配置当前bean的属性
        		name属性表示配置哪一个具体的属性
        		ref属性表示参照哪一个bean
		-->
        <property name="bookDao" ref="bookDao"/>
    </bean>

</beans>

bean可以通过name属性配置别名，如果有多个别名，可以使用空格、逗号进行间隔；一般建议还是使用id

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

    <!--name:为bean指定别名，别名可以有多个，使用逗号，分号，空格进行分隔-->
    <bean id="bookService" name="service service4 bookEbi" class="com.spring_demo.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    </bean>

    <!--scope：为bean设置作用范围，可选值为单例singloton，非单例prototype-->
    <bean id="bookDao" name="dao" class="com.spring_demo.dao.impl.BookDaoImpl"/>
</beans>

bean的作用范围scope属性
- singleton：单例（默认），即整个spring容器内，bean对应的类只有一个实列
- prototype：非单例，即bean对应的类型在每个使用的地方，注入的都是不同的实例

为什么bean默认为单例?
- bean为单例的意思是在Spring的IOC容器中只会有该类的一个对象
- bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高
bean在容器中是单例的，会不会产生线程安全问题?
- 如果对象是有状态对象，即该对象有成员变量可以用来存储数据的，
- 因为所有请求线程共用一个bean对象，所以会存在线程安全问题。
- 如果对象是无状态对象，即该对象没有成员变量没有进行数据存储的，
- 因方法中的局部变量在方法调用完成后会被销毁，所以不会存在线程安全问题。
哪些bean对象适合交给容器进行管理?
- 表现层对象
- 业务层对象
- 数据层对象
- 工具对象
哪些bean对象不适合交给容器进行管理?
- 封装实例的域对象，因为会引发线程安全问题，所以不适合。

bean的创建

构造方法

默认情况，Spring是使用类的无参构造方法来创建bean实例，并且是通过反射的方式，不管构造方法是public还是private，都能创建成功

静态工厂实例化

public interface OrderDao {
    public void save();
}

public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("order dao save ...");
    }
}

//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("factory setup....");//模拟必要的业务操作
        return new OrderDaoImpl();
    }
}

<bean id="orderDao" class="com.spring_demo.factory.OrderDaoFactory" factory-method="getOrderDao"/>

class: 工厂类的类全名
factory-mehod: 具体工厂类中创建对象的方法名

实例工厂与FactoryBean

与静态工厂的区别是，实例工厂使用的是实例方法，因此首先需要创建工厂对象，通过工厂对象调用实例方法来创建bean

public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

配置文件需要添加工厂类的bean，然后在类bean里面通过factory-bean属性引用工厂bean

<bean id="userFactory" class="com.spring_demo.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

factory-bean: 工厂的实例对象
factory-method: 工厂对象中的具体创建对象的方法名

通过实现FactoryBean接口，简化的实例工厂

创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法

public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }
    //返回所创建类的Class对象
    public Class<?> getObjectType() {
        return UserDao.class;
    }
}

在类bean的class属性直接配置工厂类，而不用在单独配置工厂bean

<bean id="userDao" class="com.spring_demo.factory.UserDaoFactoryBean"/>

查看源码会发现，FactoryBean接口其实会有三个方法，分别是:

T getObject() throws Exception;

Class<?> getObjectType();

default boolean isSingleton() {
		return true;
}

方法一: getObject()，在方法中进行对象的创建并返回
方法二: getObjectType()，返回的是被创建类的Class对象
方法三: isSingleton，从方法名中可以看出其作用是设置对象是否为单例，默认true

bean的生命周期设置

bean创建之后，想要添加内容，比如用来初始化需要用到资源
bean销毁之前，想要添加内容，比如用来释放用到的资源

方式一: 通过bean的init-method和destroy-method属性绑定对应的方法

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destory(){
        System.out.println("destory...");
    }
}

<bean id="bookDao" class="com.spring_demo.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>

Spring的IOC容器是运行在JVM中
运行main方法后,JVM启动,Spring加载配置文件生成IOC容器,从容器获取bean对象，然后调方法执行
main方法执行完后，JVM退出，这个时候IOC容器中的bean还没有来得及销毁就已经结束了
所以没有调用对应的destroy方法

主动关闭Spring容器，保证bean的destroy方法得以执行
- ApplicationContext中没有close方法
- 需要将ApplicationContext更换成ClassPathXmlApplicationContext
```
ClassPathXmlApplicationContext ctx = new 
    ClassPathXmlApplicationContext("applicationContext.xml");
```
- 调用ctx的close()方法
```
ctx.close();
```
- 或者调用ctx的registerShutdownHook()方法注册钩子关闭容器，这样不用主动调用ctx.close()，JVM销毁之前回调此函数来关闭容器

两种方式介绍完后，close和registerShutdownHook选哪个?

相同点:这两种都能用来关闭容器

不同点:close()是在调用的时候关闭，registerShutdownHook()是在JVM退出前调用关闭。

分析上面的实现过程，会发现添加初始化和销毁方法，即需要编码也需要配置，实现起来步骤比较多也比较乱。

Spring提供了两个接口来完成生命周期的控制，好处是可以不用再进行配置init-method和destroy-method

方式二：实现InitializingBean与DisposableBean接口

修改BookServiceImpl类，添加两个接口InitializingBean， DisposableBean并实现接口中的两个方法afterPropertiesSet和destroy

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
    public void save() {
        System.out.println("book service save ...");
        bookDao.save(); 
    }
    public void destroy() throws Exception {
        System.out.println("service destroy");
    }
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
}

bean生命周期小结

(1)关于Spring中对bean生命周期控制提供了两种方式:

在配置文件中的bean标签中添加init-method和destroy-method属性
类实现InitializingBean与DisposableBean接口，这种方式了解下即可。

(2)对于bean的生命周期控制在bean的整个生命周期中所处的位置如下:

初始化容器
- 1.创建对象(内存分配)
- 2.执行构造方法
- 3.执行属性注入(set操作)
- 4.执行bean初始化方法
使用bean
- 1.执行业务操作
关闭/销毁容器
- 1.执行bean销毁方法

(3)关闭容器的两种方式:

ConfigurableApplicationContext是ApplicationContext的子类
- close()方法
- registerShutdownHook()方法

依赖注入DI

setter注入

public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}
public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}

public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    private int count;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void setCount(int count) {
        this.count= count;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

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

    <bean id="bookDao" class="com.spring_demo.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.spring_demo.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
        <property name="count" value="1"/>
    </bean>
</beans>

ref: 注入应用类型，引用其他bean的id或者name
value: 注入简单数据类型，Spring在注入的时候会自动进行类型转换

构造器注入

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    private int count;

    public BookServiceImpl(BookDao bookDao, int count) {
        this.bookDao = bookDao;
        this.count = count;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

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

    <bean id="bookDao" class="com.spring_demo.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.spring_demo.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="count" value="1"/>
    </bean>
</bean>

只是把property换成了constructor-arg
介绍完两种参数的注入方式，具体我们该如何选择呢?

强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
- 强制依赖指对象在创建的过程中必须要注入指定的参数
可选依赖使用setter注入进行，灵活性强
- 可选依赖指对象在创建过程中注入的参数可有可无
Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
自己开发的模块推荐使用setter注入

这节中主要讲解的是Spring的依赖注入的实现方式:

setter注入

简单数据类型

<bean ...>
	<property name="" value=""/>
</bean>

引用数据类型

<bean ...>
	<property name="" ref=""/>
</bean>

构造器注入

简单数据类型

<bean ...>
	<constructor-arg name="" index="" type="" value=""/>
</bean>

引用数据类型

<bean ...>
	<constructor-arg name="" index="" type="" ref=""/>
</bean>

依赖注入的方式选择上
- 建议使用setter注入
- 第三方技术根据情况选择

自动装配

IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配
查找方式

按类型（常用）
按名称
按构造方法
不启用自动装配

自动装配只需要修改applicationContext.xml配置文件即可:

(1)将<property>标签删除

(2)在<bean>标签中添加autowire属性

首先来实现按照类型注入的配置

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

    <bean class="com.spring_demo.dao.impl.BookDaoImpl"/>
    <!--autowire属性：开启自动装配，通常使用按类型装配-->
    <bean id="bookService" class="com.spring_demo.service.impl.BookServiceImpl" autowire="byType"/>

</beans>

注意事项:

需要注入属性的类中对应属性的setter方法不能省略
被注入的对象必须要被Spring的IOC容器管理
按照类型在Spring的IOC容器中如果找到多个对象，会报NoUniqueBeanDefinitionException

一个类型在IOC中有多个对象，还想要注入成功，这个时候就需要按照名称注入，配置方式为:

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

    <bean class="com.spring_demo.dao.impl.BookDaoImpl"/>
    <!--autowire属性：开启自动装配，通常使用按类型装配-->
    <bean id="bookService" class="com.spring_demo.service.impl.BookServiceImpl" autowire="byName"/>

</beans>

注意事项:

按照名称注入中的名称指的是什么?
- bookDao是private修饰的，外部类无法直接方法
- 外部类只能通过属性的set方法进行访问
- 对外部类来说，setBookDao方法名，去掉set后首字母小写是其属性名
  - 为什么是去掉set首字母小写?
  - 这个规则是set方法生成的默认规则，set方法的生成是把属性名首字母大写前面加set形成的方法名
- 所以按照名称注入，其实是和对应的set方法有关，但是如果按照标准起名称，属性名和set对应的名是一致的
如果按照名称去找对应的bean对象，找不到则注入Null
当某一个类型在IOC容器中有多个对象，按照名称注入只找其指定名称对应的bean对象，不会报错

两种方式介绍完后，以后用的更多的是按照类型注入。

最后对于依赖注入，需要注意一些其他的配置特征:

自动装配用于引用类型依赖注入，不能对简单类型进行操作
使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

集合注入

public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    
public class BookDaoImpl implements BookDao {

    private int[] array;

    private List<String> list;

    private Set<String> set;

    private Map<String,String> map;

    private Properties properties;

     public void save() {
        System.out.println("book dao save ...");

        System.out.println("遍历数组:" + Arrays.toString(array));

        System.out.println("遍历List" + list);

        System.out.println("遍历Set" + set);

        System.out.println("遍历Map" + map);

        System.out.println("遍历Properties" + properties);
    }
	//setter....方法省略，自己使用工具生成
}

下面的所以配置方式，都是在bookDao的bean标签中使用进行注入

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

    <bean id="bookDao" class="com.spring_demo.dao.impl.BookDaoImpl">
        
    </bean>
</beans>

注入数组类型数据

<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>

注入List类型数据

<property name="list">
    <list>
        <value>1</value>
        <value>2</value>
        <value>3</value>
        <value>4</value>
    </list>
</property>

注入Set类型数据

<property name="set">
    <set>
        <value>1</value>
        <value>2</value>
        <value>3</value>
        <value>4</value>
    </set>
</property>

注入Map类型数据

<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="hunan"/>
        <entry key="city" value="changsha"/>
    </map>
</property>

注入Properties类型数据

<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">hunan</prop>
        <prop key="city">changsha</prop>
    </props>
</property>

说明：

property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签
List的底层也是通过数组实现的，所以<list>和<array>标签是可以混用
集合中要添加引用类型，只需要把<value>标签改成<ref>标签，这种方式用的比较少

posted @ 2025-03-08 20:41 liDB 阅读(11) 评论(0) 收藏举报

刷新页面返回顶部

yarightok

Spring -- 基础

bean的创建

构造方法

静态工厂实例化

实例工厂与FactoryBean

通过实现FactoryBean接口，简化的实例工厂

bean的生命周期设置

方式一: 通过bean的init-method和destroy-method属性绑定对应的方法

方式二：实现InitializingBean与DisposableBean接口

bean生命周期小结

依赖注入DI

setter注入

构造器注入

自动装配

集合注入

注入数组类型数据

注入List类型数据

注入Set类型数据

注入Map类型数据

注入Properties类型数据

公告