Spring----（1）Spring的配置

最新推荐文章于 2024-05-19 16:54:26 发布
最新推荐文章于 2024-05-19 16:54:26 发布
阅读量1.4k 收藏 8
点赞数 2
分类专栏： SSM 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45595929/article/details/131202863
版权

Sring配置

1 Spring相关概念

1.1 Spring Framework系统架构

在这里插入图片描述

  • 核心层：
    Core Container：核心容器
  • AOP层：
    AOP：面向切面编程。它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强
    Aspects：AOP思想实现
  • Web层： web开发
  • 数据层：
    Data Access：数据访问
    Data Integration：数据集成，
    Transactions：事务，Spring中事务管理是Spring AOP的一个具体实现
  • Test层： 单元测试与集成测试

1.2 Spring Framework 学习线路

在这里插入图片描述

1.3 Spring Framework核心概念

业务层需要调用数据层的方法，需要在业务层new数据层的对象，如果数据层的实现类发生变化，那么业务层的代码也需要跟着改变，发生变更后，都需要进行编译打包和重部署，所以，编写的过程中存在的问题是：耦合度高
解决方案：不使用new产生对象，转换为由外部提供对象。即Ioc

  • IoC ( Inversion of Control )：控制反转
    使用对象时， 由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转
  • Spring技术对IoC思想进行了实现
    Spring提供了一个容器, 称为IoC容器，用来充当IoC思想中的心外部
    IoC容器负责对象的创建、 初始化等-系列工作, 被创建或被管理的对象在 IoC容器中统称为Bean
  • DI ( Dependency Injection )：依赖注入
    在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

2 入门案例

2.1 IoC入门案例

  • 思路分析
    在这里插入图片描述
  • 代码实现
  1. 导入spring依赖坐标spring-context
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
  1. 定义Spring管理的类（接口）
public interface BookService {
    void save();
}

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();

    public void save(){
        System.out.println("book service save...");
        bookDao.save();
    }
}
  1. 创建Spring配置文件，配置对应类作为Spring管理的bean
    bean标签表示配置bean，id属性表示给bean起名字，class属性表示给bean定义类型

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

    <!--配置bean-->
    <bean id="bookDao" class="com.zs.dao.impl.BookDaoImpl"></bean>
    <bean id="bookService" class="com.zs.service.impl.BookServiceImpl"></bean>
</beans>
  1. 初始化IoC容器（Spring核心容器/Spring容器），通过容器获取bean
public class App2 {
    public static void main(String[] args) {
        //获取IOC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取Bean
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

Spring的IoC入门案例已经完成。但是在BookServiceImpl的类中依然存在BookDaoImpl对象的new操作，它们之间的耦合度还是比较高，这就需要用到下面的DI:依赖注入

2.2 DI入门案例

  • 思路分析
    在这里插入图片描述
  • 代码实现：
  1. 删除用new的形式创建的代码
public class BookServiceImpl implements BookService {
    //删除业务层中使用new的方式创建的dao对象
    private BookDao bookDao;

    public void save(){
        System.out.println("book service save...");
        bookDao.save();
    }
}
  1. 提供依赖对象对应的setter方法
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;
    }
}
  1. 配置service与dao之间的关系
    property标签表示配置当前bean的属性
    name属性表示配置哪一个具体的属性
    ref属性表示参照那个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-->
    <bean id="bookDao" class="com.zs.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.zs.service.impl.BookServiceImpl">
        <!--配置service与dao的关系-->
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

3 核心容器Bean

3.1 bean配置

3.1.1 bean基础配置

在这里插入图片描述

3.1.2 bean的别名配置

在这里插入图片描述

注意：
在这里插入图片描述

3.1.3 bean的作用范围

在这里插入图片描述

  1. 为什么bean默认为单例 ?
    bean为单例的意思是在Spring的IOC容器中只会有该类的一个对象
    bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高

  2. 适合交给容器进行管理的bean：表现层对象；业务层对象；数据层对象；工具对象

  3. 不适合交给容器进行管理的bean：封装实体的域对象

3.2 bean实例化

3.2.1 实例化bean的三种方式1----构造方法（常用）

  • bean的本质是对象，创建bean使用构造方法完成
  • 提供可访问的构造方法
public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }
    public void save() {
        System.out.println("book dao save ...");
    }
 
}
  • 配置
    <bean id="bookDao" class="com.zs.dao.impl.BookDaoImpl"/>
  • 无参方法如果不存在，将抛出异常BeanCreationException

3.2.2 实例化bean的三种方式2----静态工厂（了解）

  • 静态工厂
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        return new OrderDaoImpl();
    }
}
  • 配置
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>

这种方式一般是用来兼容早期的一些老系统，所以了解为主。

3.2.3 实例化bean的三种方式3----实例工厂（了解）与FactoryBean（常用）

  • 实例工厂
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}
  • 配置
<!--   第一步，创建实例化工厂对象，实际无意义，主要为了第二步用它-->
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
<!--   第二步，调用实例化工厂对象中的方法来创建bean，不用class属性是因为getUserDao返回值是UserDao，ioc容器是可以找到UserDao的-->
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
  • 运行测试结果
public class AppForInstanceUser {
    public static void main(String[] args) {
        ApplicationContext ctx = new 
            ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}

3.2.4 实例化bean的第四种方式----FactoryBean（常用）

  • FactoryBean
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        //返回dao实现类的实例
        return new UserDaoImpl();
    }
    //返回所创建类的Class对象
    public Class<?> getObjectType() {
        //返回dao接口的字节码
        return UserDao.class;
    }
}
  • 配置
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>
  • FactoryBean设置单例、非单例：
    将isSingleton()方法进行重写，修改返回为false（默认为true单例）
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }
 
    public Class<?> getObjectType() {
        return UserDao.class;
    }
 
    public boolean isSingleton() {
        return false;
    }
}

3.3 bean生命周期

  • 生命周期：从创建到消亡的完整过程,例如人从出生到死亡的整个过程就是一个生命周期

  • bean生命周期：bean对象从创建到销毁的整体过程
    在这里插入图片描述

  • bean生命周期控制：在bean创建后到销毁前做一些事情。

  • 生命周期控制方式一：
    提供生命周期控制方法

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

    public void init(){
        System.out.println("init...");
    }
    public void destroy(){
        System.out.println("destroy...");
    }
}
  • 配置生命周期控制方法
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>
  • 运行结果：
    在这里插入图片描述

init方法执行了，但是destroy方法却未执行。原因：Spring的IOC容器是运行在JVM中，运行main方法后，JVM启动，Spring加载配置文件生成IOC容器，从容器获取bean对象，然后调方法执行；main方法执行完后，JVM退出，这个时候IOC容器中的bean还没有来得及销毁就已经结束了；所以没有调用对应的destroy方法。
在这里插入图片描述

  • 解决方法一：使用close()方法在虚拟机退出之前将容器关闭（比较暴力）
    由于ApplicationContext中没有close方法，需要将ApplicationContext更换成ClassPathXmlApplicationContext，再调用ctx的close()方法
public class App2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        ctx.close();
    }
}

在这里插入图片描述

  • 解决方法二：设置关闭钩子，注册钩子关闭容器
    容器启动后加了个标记，让JVM在退出之前回调此函数来关闭容器
public class App2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        ctx.registerShutdownHook();
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //ctx.close();
    }
}

两种方式的区别：:
close()是在调用的时候强制关闭，如果后面还有IOC的相关代码会报错
registerShutdownHook()是在JVM退出前调用关闭，可以放在任何位置
当然两种方法我们都不用写，我们最终做的是web应用，关闭容器应该伴随Tomcat关闭一块的

  • 生命周期控制方式二：
    接口控制（了解）
public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;

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

    //提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("service destroy...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init...");
    }
}

在这里插入图片描述

  • 小细节
    对于InitializingBean接口中的afterPropertiesSet方法，即属性设置之后
    对于BookServiceImpl来说，bookDao是它的一个属性，setBookDao方法是Spring的IOC容器为其注入属性的方法
    试验：
public void setBookDao(BookDao bookDao) {
        System.out.println("set...");
        this.bookDao = bookDao;
    }

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

  • 小结
    在这里插入图片描述

4 依赖注入

  • 思考
    在这里插入图片描述
  • 依赖注入方式
    setter注入：简单类型和引用类型 .
    构造器注入：简单类型和引用类型

4.1 setter注入

4.1.1 setter注入----引用类型

  • 在bean中定义引用类型属性并提供可访问的set方法
public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}
  • 配置中使用property标签ref属性注入引用类型对象
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <property name="bookDao" ref="bookDao"/>
</bean>
 
<bean id="bookDao" class="com.itheima.dao.imipl.BookDaoImpl"/>

4.1.2 setter注入----简单类型

  • 在bean中定义简单类型属性并提供可访问的set方法
public class BookDaoImpl implements BookDao {
 
    private String databaseName;
    private int connectionNum;
 
    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }
 
    public void setDatabaseName(String databaseName) {
        this.databaseName = databaseName;
    }
 
    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}
  • 配置中使用property标签value属性注入简单类型数据
<?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.itheima.dao.impl.BookDaoImpl">
        <property name="databaseName" value="mysql"/>
         <property name="connectionNum" value="10"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

4.2 构造器注入

4.2.1 构造器注入----引用类型

  • 在bean中定义引用类型属性并提供可访问的构造方法
public class BookServiceImpl implements BookService{
    private BookDao bookDao;
 
    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }
 
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}
  • 配置中使用constructor-arg标签ref属性注入引用类型对象
    name属性的值为构造函数中构造方法形参的参数名
<?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.itheima.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>
</beans>

4.2.2 构造器注入----简单类型

public class BookDaoImpl implements BookDao {
    private String databaseName;
    private int connectionNum;
 
    public BookDaoImpl(String databaseName, int connectionNum) {
        this.databaseName = databaseName;
        this.connectionNum = connectionNum;
    }
 
    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}
  • 在bean中定义简单类型属性并提供可访问的set方法
public class BookDaoImpl implements BookDao {
    private String databaseName;
    private int connectionNum;
 
    public BookDaoImpl(String databaseName, int connectionNum) {
        this.databaseName = databaseName;
        this.connectionNum = connectionNum;
    }
 
    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}
  • 配置中使用constructor-arg标签value属性注入简单类型数据
<?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.itheima.dao.impl.BookDaoImpl">
        <constructor-arg name="databaseName" value="mysql"/>
        <constructor-arg name="connectionNum" value="666"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>
</beans>

当构造函数中方法的参数名发生变化后，配置文件中的name属性也需要跟着变，存在高耦合的问题
解决方案（有缺点，了解即可）：参数名发生变化的情况并不多，并且解决方案有缺点类型限制或顺序限制

4.2.3 构造器注入----参数适配（了解）

  • 配置中使用constructor-arg标签type属性设置按形参类型注入
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
    <constructor-arg type="int" value="10"/>
    <constructor-arg type="java.lang.String" value="mysql"/>
</bean>
  • 配置中使用constructor-arg标签index属性设置按形参位置注入
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
    <constructor-arg index="1" value="100"/>
    <constructor-arg index="0" value="mysql"/>
</bean>

依赖注入方式选择：
在这里插入图片描述

4.3 依赖自动装配

  • IoC容器根据bean所依赖的资源在容器中自动查找并注入到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 class="com.itheima.dao.impl.BookDaoImpl"/>
    <!--autowire属性：开启自动装配，通常使用按类型装配-->
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
 
</beans>

需要注入属性的类中对应属性的setter方法不能省略
被注入的对象必须要被Spring的IOC容器管理
按类型注入必须保障容器中相同类型的bean唯一，否则会报NoUniqueBeanDefinitionException

  • 按名称注入
<?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.itheima.dao.impl.BookDaoImpl"/>
    <!--autowire属性：开启自动装配，通常使用按类型装配-->
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byName"/>
 
</beans>

4.4 集合注入

  • BookDaoImpl：
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方法
}
  • 集合注入：
<?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="bookDao" class="com.zs.dao.impl.BookDaoImpl">
        <property name="array">
            <array>
                <value>100</value>
                <value>200</value>
                <value>300</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>itcast</value>
                <value>itheima</value>
                <value>boxuegu</value>
                <value>chuanzhihui</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>itcast</value>
                <value>itheima</value>
                <value>boxuegu</value>
                <value>boxuegu</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="country" value="china"/>
                <entry key="province" value="henan"/>
                <entry key="city" value="kaifeng"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="country">china</prop>
                <prop key="province">henan</prop>
                <prop key="city">kaifeng</prop>
            </props>
        </property>
    </bean>
</beans>

5 案例----数据源对象的管理(了解)

了解即可，开发中更多用注解开发。

5.1 实现Driud管理

  1. 导入依赖
<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
    </dependencies>
  1. 配置数据源对象作为spring管理的bean
    Ctrl+b跟进到DruidDataSource类，按Ctrl+f12查看发现适合用setter方法注入
<?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">
    <!--管理DruidDataSource对象-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
</beans>
  1. 从IOC容器中获取对应的bean对象
public class App {
    public static void main(String[] args) {
       ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
       DataSource dataSource = (DataSource) ctx.getBean("dataSource");
       System.out.println(dataSource);
    }
}

运行一下，测试结果：
在这里插入图片描述

5.2 实现C3P0管理

  1. 导入坐标，从mvn的仓库中进行搜索
<!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>
  1. 配置数据源对象作为spring管理的bean
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_db"/>
    <property name="user" value="root"/>
    <property name="password" value="root"/>
    <property name="maxPoolSize" value="1000"/>
</bean>
  1. 运行程序
    在这里插入图片描述
    问题：报的错为ClassNotFoundException，没有找到com.mysql.jdbc.Driver类。
    错误原因：缺少mysql的驱动包
    解决：在pom.xml把驱动包导入
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.16</version>
</dependency>

运行：
在这里插入图片描述

总结：

  1. 数据连接池在配置属性的时候，除了可以注入数据库连接四要素外还可以配置很多其他的属性，按需配置
  2. Druid和C3P0在没有导入mysql驱动包的前提下，一个没报错一个报错，说明Druid在初始化的时候没有去加载驱动，而C3P0刚好相反
  3. Druid程序运行虽然没有报错，但是当调用DruidDataSource的getConnection()方法获取连接的时候，也会报找不到驱动类的错误

5.3 加载porperties文件

问题：上面的案例中，数据库的配置写在Spring的配置文件中不利于后期维护
解决：将配置信息写在porperties文件中，使用spring加载porperties文件
实现： 在Spring的配置文件中加载properties文件；使用加载到的值实现属性注入

具体实现：

  1. resources下创建一个jdbc.properties文件，并添加对应的属性键值对
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db?ssl=false
jdbc.username=root
jdbc.password=root
  1. 开启context命名空间
    在这里插入图片描述
  2. 使用context空间加载porperties文件
<context:property-placeholder location="jdbc.properties"/>
  1. 使用属性占位符${}读取properties文件中的属性，完成属性注入
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
</bean>

设置系统属性模式：
在properties文件中配置键值对的时候，如果key设置为username值为root666，在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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
 
    <context:property-placeholder location="jdbc.properties"/>
 
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <property name="name" value="${username}"/>
    </bean>
</beans>

运行程序输出的结果不是root666而是电脑的用户名
原因：<context:property-placeholder/>标签会加载系统的环境变量，而且环境变量的值优先度更高
解决：设置系统属性模式为NEVER，表示不加载系统属性；也可以避免key设置为username

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
 
    <context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>
</beans>

加载多个properties配置文件：
在这里插入图片描述

6 容器

  1. 容器的两种创建方式

方式一：类路径下的XML配置文件（推荐使用）

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

方式二：文件系统下的XML配置文件（耦合度较高,不推荐使用）

ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\workspace\\spring\\spring_10_container\\src\\main\\resources\\applicationContext.xml");
  1. Bean的三种获取方式

方式一：根据id获取

BookDao bookDao = (BookDao) ctx.getBean("bookDao");

方式二：

BookDao bookDao = ctx.getBean("bookDao"，BookDao.class);

解决类型强转问题但是参数又多加了一个，相对来说没有简化多少

方式三：

BookDao bookDao = ctx.getBean(BookDao.class);

类似前面所学习的依赖注入中的按类型注入。必须要确保IOC容器中该类型对应的bean对象只能有一个

  1. 容器类层次结构图
    在这里插入图片描述
    ClassPathXmlApplicationContext实现ApplicationContext，ApplicationContext继承BeanFactory

  2. BeanFactory创建容器（了解）

public class AppForBeanFactory {
    public static void main(String[] args) {
        Resource resources = new ClassPathResource("applicationContext.xml");
        BeanFactory bf = new XmlBeanFactory(resources);
        BookDao bookDao = bf.getBean(BookDao.class);
        bookDao.save();
    }
}
  1. BeanFactory和ApplicationContext的区别
    BeanFactory是延迟加载，只有在获取bean对象的时候才会去创建
    ApplicationContext是立即加载，容器加载的时候就会创建bean对象
    ApplicationContext要想成为延迟加载，需要在bean中配置lazy-init=true

7 核心容器总结

7.1 容器相关

  • BeanFactory是IOC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载
  • ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载
  • ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能
  • ApplicationContext接口常用初始化类
    • ClassPathXmlApplicationContext(常用)
    • FileSystemXmlApplicationContext

7.2 bean相关

在这里插入图片描述

7.3 依赖注入相关

在这里插入图片描述
参考文章

NQGL.
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-cloud.zip
07-30
本文将深入剖析以"spring-cloud.zip"为载体的本地测试Demo，揭示其如何集成Eureka、Config、Hystrix、Gateway和OpenFeign等关键组件，实现动态配置，帮助开发者更好地理解和运用Spring Cloud。 首先，Eureka是...
spring-ai-core 0.8.1
最新发布
05-21
在API设计上，Spring AI Core遵循了Spring Boot的约定优于配置原则，提供了一系列预定义的注解和配置类，使得模型的集成变得直观且易于理解。例如，`@AIModel`注解用于标记模型 bean，`@AIEndpoint`注解则用于定义...
Spring学习
小张要努力鸭
09-06 247
Spring学习
Spring @Conditional条件匹配
yx_yancy1992的博客
06-12 118
2.条件是在注册bean定义之前可以通过编程确定的任何状态。1.指示只有在所有指定条件匹配时，组件才有资格注册。基于@Profile注释的值匹配的条件。每个条件注解的详细解析请查看对应文章比如。
spring 启动之解析配置类
weixin_45849726的博客
05-19 811
invokeBeanFactoryPostProcessors会调用实现了BeanFactoryPostProcessors接口的postProcessBeanFactory方法invokeBeanFactoryPostProcessors会调用实现BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法。
Spring条件装配注解：@Conditional及其衍生扩展注解
weixin_41821642的博客
04-10 191
条件装配是一大特点，根据是否满足指定的条件来决定是否装配 Bean ，做到了动态灵活性，starter的自动配置类中就是使用@Conditional及其衍生扩展注解@ConditionalOnXXX做到了自动装配的，所以接着之前总结的 Spring Boot自动配置原理和自定义封装一个starter，今天分析一下starter中自动配置类的条件装配注解。@Conditional：该注解是在spring4中新加的，其作用顾名思义就是按照一定的条件进行判断，满足条件才将bean注入到容器中，注解源码如下： 从代
Spring-配置
m0_67400973的博客
04-25 818
1.有网络时配置(idea版) 新建一个spring项目，选项如下： 生成目录如下： 2.环境测试 结果： 3.创建bean 在spring框架中，使用面向接口编程，实现解耦。 4.配置spring-config.xml 5.获取spring容器中的Bean 执行流程： 从类路径ClassPath中寻找指定的XML配置文件，找到并装载，完成ApplicationContext的实例化工作。 通过getBean方法从ApplicationContext容器中获取装配好的Bean实例以供使用 调
【Spring】六，属性配置
zhcf的博客
06-07 328
Spring中的属性配置
spring-boot-parent.rar
04-18
1. **父项目**：在Maven或Gradle中，父项目（Parent Project）通常不包含任何源代码，但包含一些通用的配置，如版本管理、插件管理、编码规范等。这样，所有继承这个父项目的子模块都可以共享这些配置，避免重复定义...
spring-framework-5.0.0.RELEASE-dist.zip
01-07
这些XML Schema定义了Spring配置文件中可以使用的元素和属性，帮助开发者正确地编写和验证配置文件。例如，`http://www.springframework.org/schema/beans`是Spring核心组件的配置命名空间，`...
spring-framework-4.3.30.RELEASE-dist.zip
01-07
这些XML Schema文件定义了Spring配置元素、属性及其约束，帮助开发者编写规范的配置文件，确保Spring容器能正确解析并加载配置。 Spring Framework 4.3.30.RELEASE版本的主要特性包括： 1. **依赖注入**：Spring的...
SpringBoot中的条件装配，彻底爱了！
wuxiaopengnihao1的博客
08-13 683
在实际的项目开发中，我们往往需要根据不同的环境做出不同的配置，例如：在开发环境下，我们会使用内存数据库以便快速启动服务并进行开发调试，在test环境、生产环境，会使用对应环境的数据库。在过去的应用程序开发中，我们常常会将这些环境变量写在某个指定的配置文件中，每次服务器启动的时候，会读取服务器中指定的配置文件，从而实现根据不同的环境，应用程序能做出对应的适配。但是这样的工作，对于运维来说，非常苦逼，尤其是应用程序到达50个以上的时候，会非常不好维护，每次上线改配置，全靠人肉，想想都觉得反人类～...
Spring中bean的生命周期
热门推荐
kykangyuky的博客
02-24 3万+
Spring中的bean的生命周期主要包含四个阶段：实例化Bean --＞ Bean属性填充 --＞ 初始化Bean --＞销毁Bean 首先是实例化Bean，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚末初始化的依赖时，容器就会调用doCreateBean()方法进行实例化，实际上就是通过反射的方式创建出一个bean对象 Bean实例创建出来后，接着就是给这个Bean对象进行属性填充，也就是注入这个Bean依赖的其它bean对象 属性填充完成后，进行...
Spring IOC详细配置与使用
青元子的博客
06-08 1万+
前言：复习了解下Spring，顺便记录下这个过程以供日后翻阅。SpringIoc：    按照我个人的理解来说，SpringIOC（Inversion of Control）控制反转：指就是说原先在对象中要使用另一个对象就必须要显式的去创建另一个对象的实例，例如通过构造方法或者是调用工厂方法（工厂方法最终也是需要new，因为这是Java创建对象所必须的）来获得。而Spring提供了IOC容器来帮我...
Spring的配置方式
weixin_49983276的博客
03-28 304
Spring的配置方式 开发工具与关键技术：IDEA与Java 撰写时间：2022/3/27 传统的XML配置方式 SpringXML配置bean元素相关属性： 作为 Spring 核心机制的依赖注入，改变了传统的编程习惯，对组件的实例化不再由应用程序完成，转而交由 Spring 容器完成，在需要时注入应用程序中，从而对组件之间依赖关系进行了解耦。这一切都离不开 Spring 配置文件中使用的 元素。 Spring 容器可以被看作一个大工厂，而 Spring 容器中的 Bean 就相当于该工厂的产品。如果
Spring使用配置类
程序媛乐园
10-23 1162
装配bean的三种方式 隐式的bean发现机制和自动装配； 在Java中进行显示的配置； 在XML中进行显示的配置。 自动装配 组件扫描 @Component：自动满足bean之间的依赖 @ComponentScan：自动发现应用程序中创建的类 自动装配 @Autowired：自动满足bean之间的依赖 定义配置类 @Configuration：表示当前类是一个配置类 ...
Spring简介及基本配置
弱水三千、先干为敬
09-03 431
1、Spring简介 1.1 什么是Spring Spring是一个轻量级的控制反转(IoC/DI)和面向切面编程(AOP)的开源容器框架，致力于构建轻量级的JavaEE应用，简化应用开发，本身涵盖了传统应用开发，还拓展到移动端，大数据等领域。 什么是容器（Container）：从程序设计角度看就是装对象的的对象，因为存在放入、拿出等操作，所以容器还要管理对象的生命周期，如Tomcat就是Serv...
Spring 事务的配置和使用详解（包括手动对事务的控制部分）
whbing1471的博客
01-05 1万+
最近项目中用到了spring的注解类的事务管理，所以特地学习和记录一下spring的配置和使用。项目中使用的是springMVC + mybatis + mysql。spring的版本是4.3.0.RELEASE。1. spring 注解事务的配置Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式
Spring02-配置管理第三方bean
qq_64137391的博客
10-21 407
使用spring来配置管理druid数据库连接池1.在pom.xml中添加druid依赖2.由于druid是第三方bean，我们需要对其源码进行分析，如依赖如何注入，setter还是构造器。3.在applicationContext.xml配置文件中导入bean，让IoC容器进行管理，数据库连接4要素——Driver、url、userName、password4.初始化IoC容器，通过IoC容器获取bean。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值