Spring Bean

后端 spring

笔记

发布日期: 2020-09-08

更新日期: 2022-02-28

文章字数: 5.5k

阅读时长: 23 分

阅读次数:

一、概念与定义

1、什么是Spring beans?

Bean: 在Spring中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。Bean是由Spring IoC容器实例化，组装和以其他方式管理的对象。否则，bean仅仅是应用程序中许多对象之一。Bean及其之间的依赖关系反映在容器使用的配置元数据中。

Spring Beans是构成Spring应用核心的Java对象。这些对象由Spring IoC容器实例化、组装、管理。这些对象通过容器中配置的元数据创建，例如，使用XML文件中定义的创建。
在Spring中创建的beans都是单例的beans。在bean标签中有一个属性为”singleton”, 如果设为true，该bean是单例的，如果设为false，该bean是原型bean。Singleton属性默认设置为true。因此，spring框架中所有的bean都默认为单例bean。

2、一个 Spring Bean 定义包含什么？

一个Spring Bean 的定义包含容器必知的所有配置元数据，包括如何创建一个bean，它的生命周期详情及它的依赖。

3、如何给Spring 容器提供配置元数据?

这里有三种重要的方法给Spring 容器提供配置元数据。

（1）XML配置文件。
（2）基于注解的配置。
（3）基于Java的配置

二、基于xml方式管理Bean

1、使用xml配置注入属性，set方式注入属性，有参构造方法注入（创建对象时候，默认也是执行无参数构造方法完成对象创建）

    <!--配置Book对象创建,并注入属性
        id属性：唯一标识
        class属性：类全路径（包类路径） 
        set方法注入属性-->
    <bean id="book" class="com.micah.spring.Book">
      <!--使用Property来进行属性注入-->
        <property name="bname" value="上海...研究所"/>
        <property name="bauthor" value="Micah"/>
    </bean>

    <!--有参构造方法注入属性-->
    <bean id="orders" class="com.micah.spring.Orders">
        <constructor-arg index="0" value="haha"/>
        <constructor-arg index="1" value="hahhahahahha"/>
    </bean>

2、使用P名称空间注入（了解）

使用 p 名称空间注入，可以简化基于 xml 配置方式

第一步添加 p 名称空间在配置文件中

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

第二步进行属性注入，在 bean 标签里面进行操作

<!--2 set 方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功"p:bauthor="无名氏">
</bean>

3、注入一些特殊类型的属性

（1）字面量

<!--null 值-->
<property name="address">
    <null/>
</property>

（2）属性值包含特殊符号

<!--属性值包含特殊符号 
        1 把<>进行转义 &lt; &gt; 
        2 把带特殊符号内容写到CDATA 
        -->
<property name="address">
    <value><![CDATA[<<南京>>]]></value>
</property>

4、注入外部Bean

（1）创建两个类 service 类和 dao 类

（2）在 service 调用 dao 里面的方法

（3）在 spring 配置文件中进行配置

public class UserService {

    // 创建UserDao的对象，并设置set()方法
    private UserDao userDao;

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

    public void add(){
        System.out.println("service add...");

        // 1、原始方式：创建UserDao对象
        /*UserDao userDao = new UserDaoImpl();
        userDao.update(); */
    }
}

(4)在 spring配置文件中进行配置

<!--1 service和dao的创建-->
    <bean id="userService" class="com.micah.spring.service.UserService">
        <!--注入UserDao的对象
            name:属性值，类里面属性名称
            ref:属性值，创建UserDao对象bean标签ID值
        -->
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>
    <bean id="userDaoImpl" class="com.micah.spring.dao.UserDaoImpl"/>

5、注入内部Bean属性

（1）一对多关系：部门和员工一个部门有多个员工，一个员工属于一个部门部门是一，员工是多

（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

public class Department {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

public class Emp {
private String ename;
private String gender;
//员工属于某一个部门，使用对象形式表示
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;

<!--内部 bean-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--设置对象类型属性-->
<property name="dept">
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
<property name="dname" value="安保部"></property>
</bean>
</property>
</bean>

6、注入属性-级联赋值

（1）第一种写法

<bean id="employee" class="com.micah.spring.bean.Employee">
        <!--普通属性-->
        <property name="eName" value="Micah"/>
        <property name="gender" value="男"/>
        <!--设置对象属性-->
        <property name="department">
            <bean id="department" class="com.micah.spring.bean.Department">
                <property name="dname" value="安保部门"/>
            </bean>
        </property>
    </bean>

（2）第二种写法(需声明对象department的get方法)

<!--级联赋值-->
    <bean id="employee" class="com.micah.spring.bean.Employee">
        <!--普通属性-->
        <property name="eName" value="Micah"/>
        <property name="gender" value="男"/>
        <!--级联赋值-->
        <property name="department" ref="department"/>
        <property name="department.dname" value="技术部"/>
    </bean>
    <bean id="department" class="com.micah.spring.bean.Department">
        <property name="dname" value="财务部"/>
    </bean>

7、注入集合属性

1、注入数组类型属性

2、注入 List 集合类型属性

3、注入 Map 集合类型属性

（1）创建类，定义数组、 list、 map、 set 类型属性，生成对应 set 方法

public class Stu {
    //1 数组类型属性
    private String[] courses;
    //2 list 集合类型属性
    private List<String> list;
    //3 map 集合类型属性
    private Map<String,String> maps;
    //4 set 集合类型属性
    private Set<String> sets;
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
}

<!--1 集合类型属性注入-->
<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
<!--数组类型属性注入-->
<property name="courses">
    <array>
        <value>java 课程</value>
        <value>数据库课程</value>
    </array>
</property>
<!--list 类型属性注入-->
<property name="list">
    <list><value>张三</value>
        <value>小三</value>
    </list>
    </property>
<!--map 类型属性注入-->
<property name="maps">
    <map>
        <entry key="JAVA" value="java"></entry>
        <entry key="PHP" value="php"></entry>
    </map>
</property>
<!--set 类型属性注入-->
<property name="sets">
    <set>
        <value>MySQL</value>
        <value>Redis</value>
    </set>
</property>
</bean>

4、在集合里面设置对象类型值

<!--创建多个 course 对象-->
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
    <property name="cname" value="Spring5 框架"></property>
</bean>
<bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
    <property name="cname" value="MyBatis 框架"></property>
</bean>
<!--注入 list 集合类型，值是对象-->
<property name="courseList">
    <list>
        <ref bean="course1"></ref>
        <ref bean="course2"></ref>
    </list>
</property>

5、把集合注入部分提取出来

1、在 spring配置文件中引入名称空间 util

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

2、使用 util标签完成 list集合注入提取

    <!--1、提取list集合类型属性的注入-->
    <util:list id="booklist">
        <value>Spring</value>
        <value>Java</value>
        <value>JVM Machine</value>
    </util:list>

    <!--2、提取list集合类型属性的注入使用
    scope:(1)"prototype"多实例
        （2）"singleton"单实例
    -->
    <bean id="book" class="com.micah.spring.collection.Book" scope="prototype">
        <property name="list" ref="booklist"/>
    </bean>
</beans>

三、FactoryBean

1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）

普通 bean：在配置文件中定义 bean 类型就是返回类型
工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样

2、案例演示

第一步创建类，让这个类作为工厂 bean，实现接口 FactoryBean
第二步实现接口里面的方法，在实现的方法中定义返回的 bean 类型
定义MyBean对象返回的实际是Course对象

public class MyBean implements FactoryBean<Course> {

    /**
     * 定义返回bean
     */
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setcName("abc");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

<
bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean">
</bean>

@Test
public void test3() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean3.xml");
Course course = context.getBean("myBean", Course.class);
System.out.println(course);
}

四、Spring Bean作用域

1、在 Spring 里面，你怎样定义类的作用域?

当定义一个在Spring里，我们还能给这个bean声明一个作用域。它可以通过bean 定义中的scope属性来定义。如，当Spring要在需要的时候每次生产一个新的bean实例，bean的scope属性被指定为prototype。另一方面，一个bean每次使用的时候必须返回同一个实例，这个bean的scope 属性必须设为 singleton。

@Test
public void test3() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean3.xml");
    //course1和course2的地址一样，默认为单例singleton
    Course course1 = context.getBean("myBean", Course.class);
    Course course2 = context.getBean("myBean", Course.class);
System.out.println(course);
}

2、解释Spring支持的几种bean的作用域。

Spring框架支持以下五种bean的作用域：

singleton : bean在每个Spring ioc 容器中只有一个实例，在加载spring配置的时候创建单实例对象。
prototype：一个bean的定义可以有多个实例。不是在加载spring配置的时候创建对象，而是在调用getBean方法的时候创建多实例对象。
request：将单个bean定义的范围限定为单个HTTP请求的生命周期；也就是说，每个HTTP请求都有一个自己的bean实例，它是在单个bean定义的后面创建的。仅在基于Web的Spring ApplicationContext上下文中有效。
session：将单个bean定义的作用域限定为HTTP会话的生命周期。仅在web的Spring ApplicationContext上下文中有效。
application:将单个bean定义的作用域限定为ServletContext的生命周期。仅在基于web的Spring ApplicationContext上下文中有效。
websocket:将单个bean定义的作用域限定为WebSocket的生命周期。仅在基于web的Spring ApplicationContext上下文中有效。

3、 Spring框架中的单例bean是线程安全的吗?

不，Spring框架中的单例bean不是线程安全的。

五、Spring Bean生命周期

1、Spring框架中bean的生命周期。

Spring容器从XML 文件中读取bean的定义，并实例化bean。
Spring根据bean的定义填充所有的属性。
如果bean实现了BeanNameAware 接口，Spring 传递bean 的ID 到 setBeanName方法。
如果Bean实现了 BeanFactoryAware 接口， Spring传递beanfactory 给setBeanFactory方法。
如果有任何与bean相关联的BeanPostProcessors，Spring会在postProcesserBeforeInitialization()方法内调用它们。
如果bean实现IntializingBean了，调用它的afterPropertySet方法，如果bean声明了初始化方法，调

用此初始化方法。如果有BeanPostProcessors 和bean关联，这些bean的postProcessAfterInitialization()方法将被调用。
如果bean实现了 DisposableBean，它将调用destroy()方法。

//无bean 的后置处理器， bean 生命周期有五步
（1）通过构造器创建 bean 实例（无参数构造）
（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
（3）调用 bean 的初始化的方法（需要进行配置初始化的方法）
（4） bean 可以使用了（对象获取到了）
（5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

public class Orders {//无参数构造
    public Orders() {
        System.out.println("第一步 执行无参数构造创建 bean 实例");
    }
    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用 set 方法设置属性值");
    }
//创建执行的初始化的方法
    public void initMethod() {
        System.out.println("第三步 执行初始化的方法");
    }
//创建执行的销毁的方法
    public void destroyMethod() {
        System.out.println("第五步 执行销毁的方法");
    }
}

@Test
public void testBean3() {
// ApplicationContext context =
// new ClassPathXmlApplicationContext("bean4.xml");
    ClassPathXmlApplicationContext context =new ClassPathXmlApplicationContext("bean4.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("第四步 获取创建 bean 实例对象");
    System.out.println(orders);
    //手动让 bean 实例销毁
    context.close();
}

//initmethod指定初始化方法，destroy-method指定销毁方法
<bean id="orders" class="com.atguigu.spring5.bean.Orders" initmethod="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机"></property>
</bean>

//bean 的后置处理器， bean 生命周期有七步
（1）通过构造器创建 bean 实例（无参数构造）
（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）
（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
（6） bean 可以使用了（对象获取到了）
（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

    public class MyBeanPost implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName)
        throws BeansException {
            System.out.println("在初始化之前执行的方法");
            return bean;
        }
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName)
        throws BeansException {
            System.out.println("在初始化之后执行的方法");
            return bean;
        }
    }

<bean id="MyBeanPost" class="com.xx.MyBeanPost"></bean>

执行结果

第一步 执行无参数构造创建 bean 实例
第二步 调用 set 方法设置属性值
在初始化之前执行的方法
第三步 执行初始化的方法
在初始化之后执行的方法
第四步 获取创建 bean 实例对象
第五步 执行销毁的方法

2.哪些是重要的bean生命周期方法？你能重载它们吗？

有两个重要的bean 生命周期方法，第一个是setup ，它是在容器加载bean的时候被调用。第二个方法是 teardown 它是在容器卸载类的时候被调用。

The bean 标签有两个重要的属性（init-method和destroy-method）。用它们你可以自己定制初始化和注销方法。它们也有相应的注解（@PostConstruct和@PreDestroy）。

六、Spring Bean自动装配

1、什么是bean装配?

装配，或bean 装配是指在Spring 容器中把bean组装到一起，前提是容器需要知道bean的依赖关系，如何通过依赖注入来把它们装配到一起。

2、什么是bean的自动装配？

Spring 容器能够自动装配相互合作的bean，这意味着容器不需要和配置，能通过Bean工厂自动处理bean之间的协作。

根据指定装配规则（属性名称或者属性类型），spring自动将匹配的属性值进行注入

3、解释不同方式的自动装配。

有五种自动装配的方式，可以用来指导Spring容器用自动装配方式来进行依赖注入。

no：默认的方式是不进行自动装配，通过显式设置ref 属性来进行装配。
byName：通过参数名自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byname，之后容器试图匹配、装配和该bean的属性具有相同名字的bean。
byType：通过参数类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件，则抛出错误。
constructor：这个方式类似于byType，但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。
autodetect：首先尝试使用constructor来自动装配，如果无法工作，则使用byType方式。

<!--实现自动装配
bean 标签属性 autowire，配置自动装配
autowire 属性常用两个值：
byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
byType 根据属性类型注入,如果有多个改类型的bean，会引发报错，因为找不到匹配的bean
-->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
<!--<property name="dept" ref="dept"></property>--></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

4、自动装配有哪些局限性 ?

自动装配的局限性是：

重写：你仍需用和配置来定义依赖，意味着总要重写自动装配。

基本数据类型：你不能自动装配简单的属性，如基本数据类型，String字符串，和类。
模糊特性：自动装配不如显式装配精确，如果有可能，建议使用显式装配。

5、你可以在Spring中注入一个null 和一个空字符串吗？

可以。

七、引入外部文件

引入 context 名称空间
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:util="http://www.springframework.org/schema/util"
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/util
http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
 在 spring 配置文件使用标签引入外部属性文件
<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${prop.driverClass}"></property>
<property name="url" value="${prop.url}"></property>
<property name="username" value="${prop.userName}"></property>
<property name="password" value="${prop.password}"></property>
</bean>

八、Spring注解

1、什么是注解

（1）注解是代码特殊标记，格式： @注解名称(属性名称=属性值, 属性名称=属性值..)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解目的：简化 xml 配置

2、什么是基于Java的Spring注解配置? 给一些注解的例子.

基于Java的配置，允许你在少量的Java注解的帮助下，进行你的大部分Spring配置而非通过XML文件。

以@Configuration 注解为例，它用来标记类可以当做一个bean的定义，被Spring IOC容器使用。另一个例子是@Bean注解，它表示此方法将要返回一个对象，作为一个bean注册进Spring应用上下文。

3、Spring 针对 Bean 管理中创建对象提供注解

（1） @Component
（2） @Service
（3） @Controller
（4） @Repository

上面四个注解功能是一样的，都可以用来创建bean 实例，只是名字便于区分

4、什么是基于注解的容器配置?

相对于XML文件，注解型的配置依赖于通过字节码元数据装配组件，而非尖括号的声明。

开发者通过在相应的类，方法或属性上使用注解的方式，直接组件类中进行配置，而不是使用xml表述bean的装配关系。

5、怎样开启注解装配？

注解装配在默认情况下是不开启的，为了使用注解装配，我们必须在Spring配置文件中配置 context:annotation-config/元素。

6、@Required 注解

这个注解表明bean的属性必须在配置的时候设置，通过一个bean定义的显式的属性值或通过自动装配，若@Required注解的bean属性未被设置，容器将抛出BeanInitializationException。

7、@Autowired 注解

@Autowired 注解提供了更细粒度的控制，包括在何处以及如何完成自动装配。它的用法和@Required一样，修饰setter方法、构造器、属性或者具有任意名称和/或多个参数的PN方法。

8、@Qualifier 注解

当有多个相同类型的bean却只有一个需要自动装配时，将@Qualifier 注解和@Autowire 注解结合使用以消除这种混淆，指定需要装配的确切的bean。

9、@value注解

该注解的作用是将我们配置文件的属性读出来，有@Value(“${}”)和@Value(“#{}”)两种方式

① ${ property : default_value }
② #{ obj.property? :default_value }第一个注入的是外部配置文件对应的property，第二个则是SpEL表达式对应的内容。 那个default_value，就是前面的值为空时的默认值。注意二者的不同，#{}里面那个obj代表对象。

10、案例演示

1.引入依赖spring-aop-5.2.6.RELEASE.jar

2.开启组件扫描

<!--开启组件扫描
1 如果扫描多个包，多个包使用逗号隔开
2 扫描包上层目录
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>

3.创建类，在类上面添加创建对象注解

//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService@Component(value = "userService") //<bean id="userService" class=".."/>
public class UserService {
    public void add() {
        System.out.println("service add.......");
    }
}

4.开启组件扫描细节配置

<!--示例 1
use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.atguigu" use-defaultfilters="false">
    <context:include-filter type="annotation"
    expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2
下面配置扫描包所有内容
context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.atguigu">
    <context:exclude-filter type="annotation"
    expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

5.基于注解方式实现属性注入

（1） @Autowired：根据属性类型进行自动装配

第一步把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

第二步在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

@Service
public class UserService {
//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
    @Autowired
    private UserDao userDao;
    public void add() {
        System.out.println("service add.......");
        userDao.add();
    }
}

（2） @Qualifier：根据名称进行注入这个@Qualifier 注解的使用，和上面@Autowired 一起使用

//定义 dao 类型属性
//不需要添加 set 方法//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

（3） @Resource：可以根据类型注入，可以根据名称注入

//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

（4） @Value：注入普通类型属性

@Value(value = "abc")
private String

6.完全注解开发

@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"com.atguigu"})//扫描的包
public class SpringConfig {
}

艾茶叶蛋

https://scanele.github.io/2020/09/08/spring-bean/

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源艾茶叶蛋 !

后端 spring

spring aop

spring aop学习笔记

2020-09-09 笔记

后端 spring

spring

spring学习笔记

2020-09-05 笔记

后端 spring

一、概念与定义

1、什么是Spring beans?

2、 一个 Spring Bean 定义包含什么？

3、如何给Spring 容器提供配置元数据?

二、基于xml方式管理Bean

1、使用xml配置注入属性，set方式注入属性，有参构造方法注入（创建对象时候，默认也是执行无参数构造方法完成对象创建）

2、使用P名称空间注入（了解）

3、注入一些特殊类型的属性

4、注入外部Bean

5、注入内部Bean属性

6、注入属性-级联赋值

7、注入集合属性

三、FactoryBean

1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）

2、 案例演示

四、Spring Bean作用域

1、在 Spring 里面，你怎样定义类的作用域?

2、解释Spring支持的几种bean的作用域。

3、 Spring框架中的单例bean是线程安全的吗?

五、Spring Bean生命周期

1、Spring框架中bean的生命周期。

2.哪些是重要的bean生命周期方法？ 你能重载它们吗？

六、Spring Bean自动装配

1、什么是bean装配?

2、什么是bean的自动装配？

3、解释不同方式的自动装配 。

4、自动装配有哪些局限性 ?

5、你可以在Spring中注入一个null 和一个空字符串吗？

七、引入外部文件

八、Spring注解

1、什么是注解

2、什么是基于Java的Spring注解配置? 给一些注解的例子.

3、Spring 针对 Bean 管理中创建对象提供注解

4、什么是基于注解的容器配置?

5、怎样开启注解装配？

6、@Required 注解

7、@Autowired 注解

8、@Qualifier 注解

9、@value注解

10、案例演示

6.完全注解开发

谢谢老板!

2、一个 Spring Bean 定义包含什么？

2、案例演示

2.哪些是重要的bean生命周期方法？你能重载它们吗？

3、解释不同方式的自动装配。