Spring框架（一）

最新推荐文章于 2024-05-09 20:47:32 发布
最新推荐文章于 2024-05-09 20:47:32 发布
阅读量539 收藏 2
点赞数
分类专栏： spring框架 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Williams10/article/details/126021514
版权

Spring简介

学习目标

  1. Spring框架设计思想
  2. 基础操作，思考操作与思想间的联系
  3. 熟悉应用操作的同时，体会思想

Spring家族

在这里插入图片描述

Spring体系结构

在这里插入图片描述

Spring核心概念

当前代码编写存在的问题

在这里插入图片描述

  • 主要痛点：耦合度偏高
  • 解决方案：使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象

程序的耦合

  • 耦合：程序间的依赖关系
  1. 类之间的依赖
  2. 方法间的依赖
  • 解耦：降低程序间的依赖关系

注意：编译期不依赖，运行期依赖。

  • 解耦思路：
    step1. 使用反射来创建对象，而避免使用new关键字
    step2. 通过读取配置文件来获取要创建的对象全限定类名
工厂模式解耦
创建Bean对象的工厂
  • Bean：可重用组件
  • JavaBean用Java语言编写的可重用组件

JavaBean>实体类

  • 作用：创建service和dao对象
  1. 需要一个配置文件来配置我们的service和dao，配置内容：唯一标识=全限定类名(key=value)
  2. 通过读取配置文件（.xml或.properties）中的配置内容，反射创建对象
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;

    //定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    private static Map<String,Object> beans;

    //使用静态代码块为Properties对象赋值
    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

    /**
     * 根据bean的名称获取对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }

    /**
     * 根据Bean的名称获取bean对象
     * @param beanName
     * @return

    public static Object getBean(String beanName){
        Object bean = null;
        try {
            String beanPath = props.getProperty(beanName);
//            System.out.println(beanPath);
            bean = Class.forName(beanPath).newInstance();//每次都会调用默认构造函数创建对象
        }catch (Exception e){
            e.printStackTrace();
        }
        return bean;
    }*/
}

核心概念

IOC

降低程序间的耦合（依赖关系）

  • IOC（Inversion of Control）控制反转：
    使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部（将new对象的权力交给Spring，直接从Spring中获取对象使用）。
  • Spring技术对IOC思想进行了实现
  1. Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的“外部”。
  2. IOC容器负责对象的创建，初始化等一系列工作，被创建或被管理的对象在IOC容器中统称为Bean。
    作用：获取spring容器的Ioc核心容器，并根据id获取对象
ApplicationContext的三个常用实现类
  • ClassPathXmlApplicationContext:可以加载类路径下的配置文件，要求配置文件必须在类路径下。（常用）
  • FileSystemXmlApplicationContext：可以加载磁盘任意路径下的配置文件(必须拥有放文权限)
  • AnnotationConfigApplicationContext：当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
核心容器的两个接口引发出的问题
  • ApplicationContext：单例对象适用

在构建核心容器时，创建对象采用的策略是采用立即加载的方式，即为只要一读取完配置文件马上就创建配置文件中配置的对象

  • BeanFactory：多例对象适用

在构建核心容器时，创建对象采用的策略时采用延迟加载的方式，即为什么时候根据id获取对象了，什么时候才真正的创建对象

DI
  • DI（Dependency Injection）依赖注入：
    在容器中建立bean与bean之间的依赖关系的整个过程。
  • 目标：充分解耦
  1. 使用IOC容器管理bean（IOC）
  2. 在IOC容器内将有依赖关系的bean进行关系绑定（DI）
  • 最终效果：
    使用对象时不仅可以直接从IOC容器中获取，并且获取到bean已经绑定了所有的依赖关系

IOC和DI入门案例

IOC入门案例

> <bean>标签中id属性和class属性的作用

思路分析
  1. 管理什么(Service和Dao)
  2. 如何将被管理的对象告知IOC容器(配置文件)
  3. 被管理的对象交给IOC容器，如何获取到IOC容器(接口)
  4. IOC容器得到后，如何从容器中获取bean(接口方法)
  5. 使用Spring导入哪些坐标(pom.xml)
实现步骤

step1. 导入Spring坐标
step2. 定义Spring管理的类(接口)
step3. 创建Spring配置文件，配置对应类作为Spring管理的bean对象
step4. 初始化IOC容器(Spring核心容器/Spring容器)，通过容器获取bean对象

代码实现

step1.

<dependencies>
    <!--导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
</dependencies>

step2.

  • BookDao接口和BookDaoImpl实现类
public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}
  • BookService接口和BookServiceImpl实现类
public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}
  • step3.
  • 定义applicationContext.xml配置文件并配置BookServiceImpl
<?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="bookService" class="com.itheima.service.impl.BookServiceImpl"></bean>

</beans>

注意事项：bean定义时id属性在同一个上下文中(IOC容器中)不能重复

  • step4.
public class App {
    public static void main(String[] args) {
        //1.创建IoC容器对象，加载spring核心配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 从IOC容器中获取Bean对象(BookService对象)
        BookService bookService= (BookService)ctx.getBean("bookService");
        //3 调用Bean对象(BookService对象)的方法
        bookService.save();
    }
}

DI入门案例

<property>标签中name属性和ref属性的作用

DI思路分析
  1. 基于IOC管理bean
  2. Service中使用new形式创建的Dao对象是否保留(否)
  3. Service中需要的Dao对象如何进行到Service中(提供方法)
  4. Service与Dao间的关系如何描述(配置)
实现步骤

step1. 删除使用new的形式创建对象的代码
step2.提供依赖对象对应的setter方法
step3.配置Service与Dao之间的关系

代码实现
  • step1.
public class BookServiceImpl implements BookService {
    private BookDao bookDao;  //【第一步】删除使用new的形式创建对象的代码
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}
  • step2.
public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //【第二步】提供依赖对象对应的setter方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}
  • step3.

在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属性：表示给bean起名字
    	class属性：表示给bean定义类型
	-->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

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

Bean的基础配置

  • 在<bean>标签上如何配置别名
  • Bean的默认作用范围，修改方法

Bean基础配置

在这里插入图片描述

Bean别名配置

在这里插入图片描述* 注意事项获取bean无论是通过id还是bean获取，如果无法获取到，将抛出异常NoSuchBeanDefinitionException

NoSuchBeanDefinitionException:No bean named ‘bookeServiceImpl’ available

Bean作用范围配置

在这里插入图片描述

提示：scope的取值不仅仅只有singleton和prototype，还有request、session、application、websocket，表示创建出的对象放置在web容器(tomcat)对应位置

Bean的实例化

spring对bean的管理细节
  1. 创建bean的三种方式
  2. bean对象的作用范围
  3. bean对象的生命周期

Bean创建方法

Bean本质为对象，创建Bean使用构造方法。

实例化Bean的三种方式

构造方法方式

使用默认构造函数创建

  • 在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
  • 采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。
  • BookDaoImpl实现类
public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }
    public void save() {
        System.out.println("book dao save ...");
    }
}
  • applicationContext.xml配置
<!--把对象的创建交给spring来管理-->
<!--方式一：构造方法实例化bean-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
  • AppForInstanceBook测试类
public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

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

        bookDao.save();
    }
}
静态工厂方式
  • 使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)
  • OrderDao接口和OrderDaoImpl实现类
public interface OrderDao {
    public void save();
}
public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("order dao save ...");
    }
}
  • OrderDaoFatory工厂类
//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("factory setup....");
        return new OrderDaoImpl();
    }
}
  • applicationContext.xml配置
<!--方式二：使用静态工厂实例化bean-->
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>
  • AppForInstanceOrder测试类
public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();
    }
}
实例工厂方式
  • 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）
    • UserDao接口和UserDaoImpl实现类
public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}
    • UserDaoFactory工厂类
//实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}
    • applicationContext.xml配置
<!--方式三：使用实例工厂实例化bean-->
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>

<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
    • AppForInstanceUser测试类
public class AppForInstanceUser {
    public static void main(String[] args) {
        //        //创建实例工厂对象
        //        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //        //通过实例工厂对象创建对象
        //        UserDao userDao = userDaoFactory.getUserDao();
        //        userDao.save();
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}

bean的作用范围调整

bean标签的scope属性：
  • 作用：用于指定bean的作用范围
  • 取值： 常用的就是单例的和多例的

singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

Bean的生命周期

  • 多例的Bean能够配置并执行销毁的方法
  • 如何执行Bean销毁的方法

生命周期相关概念介绍

  • 生命周期：从创建到消亡的完整过程
  • Bean生命周期：Bean从创建到销毁的完整过程
  • Bean生命周期控制：在Bean创建后到销毁前做一些事情

Bean销毁时机

  • 容器关闭前触发Bean的销毁
  • 关闭容器方式：
  1. 手工关闭容器：
  • ConfigurableApplicationContext接口close()操作
  • 注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机：ConfigurableApplicationContext接口registerShutdownHook()操作

依赖注入(DI配置) Dependency Injection

  • 概念：对程序间依赖关系的维护

依赖注入方式

依赖注入的两种方式
  • setter注入：简单类型、引用类型
  • 构造器注入：简单类型、引入类型
setter方式注入
  • setter方式注入使用的子标签：
  • 配置中使用property标签ref属性注入引用类型对象
  • 在Bean中定义引用类型属性并提供可访问的set方法
  • 配置中使用property标签value属性注入简单类型数据
  • 标签：property
  • 位置：bean标签的内部
  • 标签的属性
    • name：用于指定注入时所调用的set方法名称
    • value：用于提供基本类型和String类型的数据
    • ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
  • 优势：
    创建对象时没有明确的限制，可以直接使用默认构造函数
  • 劣势：
    如果有某个成员必须有值，则获取对象是有可能setter方法没有执行。
引用类型

在这里插入图片描述

简单类型

在这里插入图片描述

构造方式注入
  • 构造方式注入使用的子标签：
  • 在Bean中定义引用类型属性并提供可访问的构造方法
  • 配置中使用constructor-arg标签ref属性注入引用类型对象
  • 在Bean中定义引用类型属性并提供可访问的set方法
  • 配置中使用constructor-arg标签value属性注入简单类型数据

  • 标签:constructor-arg

  • 位置：bean标签的内部

  • 标签中的属性

    • type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
    • index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
    • name：用于指定给构造函数中指定名称的参数赋值 常用的
      以上三个用于指定给构造函数中哪个参数赋值
    • value：用于提供基本类型和String类型的数据
    • ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

  • 优势：
    在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。

  • 劣势：
    改变了bean对象的实例化方式，使我们在创建对象时，即使用不到这些数据，也必须提供。

引用类型

在这里插入图片描述

简单类型

在这里插入图片描述

复杂类型/集合类型的注入

  • 用于给List结构集合注入的标签：list array set
  • 用于个Map结构集合注入的标签:map props

结构相同，标签可以互换

依赖注入方式选择

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

依赖自动装配

自动装配

  • 概念：IOC容器根据Bean所依赖的资源在容器中自动寻找并注入到Bean中的过程
  • 自动装配方式：
    .按类型

按名称
按构造方法
不启用自动装配

自动装配类型
依赖自动装配

配置中使用bean标签autowire属性设置自动装配的类型

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
依赖自动装配特征
  1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
  2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
  3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
  4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

集合注入

注入数组类型数据
<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>
注入List类型数据
<property name="list">
    <list>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>
注入Set类型数据
<property name="set">
    <set>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>
注入Map类型数据
<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>
注入Properties类型数据
<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>

说明：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签

单例与多例（补充）

单例模式

  • 概念：一个类有且仅有一个实例，并且自行实例化向整个系统提供。

多例模式（反面模式）

  • 概念：指存在一个类有多个相同实例，而且该实例都是该类本身。
  • 特点：
    • 多例类可以有多个实例。
    • 多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。

单例模式与多例模式说明

  1. 单例模式和多例模式属于对象模式。
  2. 单例模式的对象在整个系统中只有一份，而多例模式可以有多个实例类。
  3. 它们都不对外提供构造方法，即构造方法都为私有。
Williams10
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring框架 一个AOP程序.zip
05-20
AOP程序 Spring框架 前置通知 后置通知 异常通知 环绕通知
标签系列三：spring 中property解释以及property标签里面的属性
热门推荐
xiao1_1bing的博客
07-17 8万+
一、property标签： 英文解释：Bean definitions can have zero or more properties. Property elements correspond to JavaBean setter methods exposed by the bean classes. Spring supports primitives, references to ot...
Spring中的property属性
m0_71461928的博客
05-18 1940
的 bean 对象，或者该对象依赖的其他对象未能正确初始化，则也可能导致注入失败。因此，在进行属性注入时，应该仔细检查依赖关系，确保依赖的对象已经正确初始化，并且检测是否存在潜在的类型转换等问题。标签进行属性注入时，被注入的属性类型必须与依赖的 bean 类型兼容，否则可能会出现类型转换异常等问题。属性在 JavaBean 中定义为一个引用类型的变量，那么 Spring 在初始化当前 bean 时会自动查找名为。的属性注入到当前 bean 中，并且该属性依赖于名为。属性表示要注入的 bean 属性名称，
Spring 源码之 SpringProperties 类简介
最新发布
若千年后
05-09 1040
SpringProperties 是 Spring core 包中一个用于读取并加载Spring库级别属性的工具类，其读取的文件为classpath下的spring.properties文件。内部通过一个Properties对象维护读取到的属性，并对外暴露一些设置属性值或者获取属性值的的静态方法。在根据key获取属性值时，如果localProperties不存在，则从VM系统属性中获取。
logback springProperty 标签不起作用
波特多的博客
02-09 6819
logback springProperty 不起作用
spring property 属性注入详解
bruk_spp的博客
08-16 1万+
我的上一篇文章上面有比较详细的说角getBean的流程。其中对propery注入的过程通过画的流程图比较清楚的展现出来。最终是通过BeanWrapperImpl类的setValue方法来完成property注入。但是究竟是怎么样获取method然后invoke的，还不太清楚。我的想法是代码里面应该有set+Name 和get+ Name进行组合字符串的操作，但实际上并不是这样的。流程是这样的先看流...
spring详细概述，Spring体系结构，bean、property属性，Spring生命周期方法
V_99999的博客
10-28 635
Core模块：提供了框架的基本组成部分，包括控制反转（Inversion of Control，IoC）和依赖注入（Dependency Injection，DI）功能。
spring框架2016
08-26
最新spring框架2016视频教程，包含源码和笔记。小白入手实用教程。
简述Spring框架（一）
12-21
Spring是分层的Java SE/EE应用full-stack轻量级开源框架，以IOC（Inverse Of Control：控制反转）和AOP（Aspect Oriented Programmaing：面向切面编程）为内核，提供了展现层Spring MVC和持久层Spring JDBC以及业务...
Spring框架.docx
04-10
了解Spring框架
Spring Cloud 框架 模板
07-16
包含 Spring Cloud Eureka 注册中心，（生产者 + 消费者） Spring Boot 模型，集成 Mybatis mysql 数据库连接； 内置 readme.md 开发说明文档，有使用的可以下载奥
【spring】springProperty 使用
一个写了10年bug的程序员日常笔记。
04-20 581
是一个在 Spring 框架中使用的SpEL（Spring Expression Language）表达式，它允许你在应用程序的配置中引用 Spring 应用程序上下文中的属性值。这个表达式通常用于从 Spring 的对象中获取配置属性的值，并将这些值插入到配置文件中，比如在 Spring Boot 的或文件中定义的属性。在 XML 文件中使用表达式是一种在 Spring 框架的 XML 配置中引用配置属性的方法。
Spring boot 中 logback 配置＜springProperty＞ 读取application.properties 中的属性
Lei_lee_coder的博客
02-10 7456
Spring Boot 中 logback 读取application.properties 中的属性 其中使用的时候发现了一个问题，就是如果使用的lobback配置文件的名称是logback.xml 会先出现先找不到设置的属性，然后项目启动起来才会找到， 比如： <springProperty scope="context" name="log.path" source="logback.path" defaultValue="logs"/> 记录日志文件存放地址属性,会在项目启动的时候想出
spring应用手册-IOC（XML配置实现）-(20)-property标签
10-03 1025
戴着假发的程序员出品 property标签 spring应用手册（第一部分） property是用来给bean的属性配置要注入的值的。这些值可以是bean或者简单值（基本类型和Stirng）。 案例： /** * @author 戴着假发的程序员 * @description */ public class AccountService { private IAccount
总结Spring Set注入方式及对property标签的理解
坚持，努力，奋斗不止
09-05 299
总结Spring Set注入方式及对property标签的理解 创建SpringDao的set方法 package com.springdemo.action; public class SpringAction { //注入对象springDao private SpringDao springDao; //一定要写被注入对象的set方法 public void setSpringDao(SpringDao springDao) { this.sp
理解Spring配置文件中的property标签中的属性
yan
03-17 2万+
1.ref引用一个已经存在的对象,value创建一个新的对象 2.value可以赋一些简单类型的值，ref可以引用其他的bean对象。
Spring property标签ref属性和ref标签区别
LittleSkey的博客
08-10 9446
ref标签和ref属性区别
Spring property设置
与望
12-19 836
1.property的设置方法一般有两种:一种是另起标签对，一种是直接设置属性。<bean id="Book_Message" class="vo.Book_message"> <property name="sessionFactory"> <ref bean="sessionFactory"/> </property> </bean><bean id="Book_
Spring Boot中logback.xml配置＜springProperty＞出现APP_NAME_IS_UNDEFINED,附完整配置
一名北漂Java程序员的学习记录！
10-22 4240
解决Spring Boot中logback.xml配置出现APP_NAME_IS_UNDEFINED，附完整配置文件

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值