spring bean的创建，生命周期

1. 初探spring

什么是spring
Spirng 是分层的Java se/ee应用full-stack（web层mvc dao层jdbc模板业务事务管理）轻量级开源框架，以IoC(inverse of control :反转和控制) 和
AOP（Aspect Oriented Programming: 面向切面编程）为内核。

还能整合开源世界著名的第三方框架和类库
spring发展历程
1997年 EJB思想。。。 2006年 ejb3.0

2017 5.0版本发布
spring的优势

3.1 方便解耦，简化开发（ioc创建dao层对象了）
3.2 aop面向切面编程
3.3 声明式事务的支持（配置一片方法控制事务控制）
3.4 方便程序测试
3.5 方便集成各种优秀的框架
3.6 降低JavaEE api的使用难度
3.7 Java源码时经典的学习范例
spring的体系结构

4.1 底层核心控制器
beans 创建对象用的
core 核心
context spring的上下文
spEl spring el表达式
4.2 上一层
aop，aspects，instrumentation，messaging
spring快速入门

5.1 spring程序开发步骤
5.1.1 导入spring开发的基本坐标包
5.1.2 编写Dao接口和实现类
5.1.3 创建spring核心配置文件（xml文件）
5.1.4 在spring配置文件中配置userdaoimpl
5.1.5 使用spring的api获得bean实例 (创建applicationContext对象)
spring下载地址

https://repo.spring.io/release/org/springframework/spring/

2. spring bean的创建

2.1 idea创建maven依赖的项目

2.2 完成项目创建

2.3 配置pom.xml, 引入maven中的依赖关系（这里引入spring框架滴）

该文件用于管理：源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。事实上，在Maven世界中，project可以什么都没有，甚至没有代码，但是必须包含pom.xml文件。

2.4 引入框架

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

	<!-- 当前项目信息 -->
    <groupId>org.example</groupId>
    <artifactId>spring_02</artifactId> <!-- 项目名 -->
    <version>1.0-SNAPSHOT</version>

    <dependencies> <!-- 导入依赖关系 spring框架 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId> <!-- junit 用来测试@Test注解 -->
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>

    </dependencies>


</project>

2.5 终于可以配置bean拉，啊啊啊

对dao接口的实现类进行bean的创建

package com.lovely.dao;

public interface UserDao {
    public void save();
}

实现类

package com.lovely.dao.impl;

import com.lovely.dao.UserDao;

public class UserDaoImpl implements UserDao {

    public void save() {
        System.out.println("save running...");
    }
    
}

创建spring核心配置文件applicationContext.xml 配置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为唯一标识 class为类所在的全路径1-->
    <bean id="userDao" class="com.lovely.dao.impl.UserDaoImpl"> </bean>
 
</beans>

测试创建的bean

package com.lovely.demo;

import com.lovely.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserDaoDemo {
    public static void main(String[] args) {
        // spring客户端
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        // getBean(id) 来得到实体类对象
        UserDao dao = (UserDao) app.getBean("userDao");
        dao.save();
    }
}

打印结果
bean通过工厂方式创建

    <!--  工厂模式 静态方法实例bean  -->
    <bean id="userDao" class="com.lovely.Factory.StaticFactory" factory-method="getUserDao"></bean>

    <!--  工厂实例方法创建bean  -->
    <bean id="factory" class="com.lovely.Factory.DynamicFactory"></bean>
    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>

2.6 bean的作用域标签范围

bean的单例模式和多例模式

	// spring容器决定帮你创建单个userdao对象 还是多个userdao对象。
    <bean id="userDao" class="com.lovely.dao.impl.UserDaoImpl" scope="singleton">
    </bean>
    <!-- crtl + d 快速赋值一行 scope = singleton 单个对象 scope = prototype 多例模式 -->

测试

package com.lovely.test;

import com.lovely.dao.UserDao;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

    @Test
    public void test1() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserDao userDao1 = (UserDao) app.getBean("userDao");
        UserDao userDao2 = (UserDao) app.getBean("userDao");

        // 如果配置bean scope是单例模式 则只产生一个对象
        // 如果配置bean scope是多例的 则spring容器中每次产生一个对象
        System.out.println(userDao1 == userDao2);

        /**
         * bean标签的创建时机
         *      singleton spring web容器创建，只有一个
         *      prototype 每次创建对象时 就会创建bean 会创建多个 gc回收
         */

    }

}

3. bean的生命周期

bean对象的创建，初始化，容器销毁，bean销毁

package com.lovely.dao.impl;

import com.lovely.dao.UserDao;

public class UserDaoImpl implements UserDao {

    public UserDaoImpl() {
        // 确定bean的生命周期 singleton prototype
        System.out.println("user dao 创建了");
    }

    public void init() {
        System.out.println("user bean init...");
    }

    public void destroy() {
        System.out.println("user bean destory...");
    }
}

配置文件

<bean id="userDao" class="com.lovely.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy">
</bean>

测试

	@Test
    public void test2() {
        // bean在spring容器中的出生创建
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao dao = (UserDao) app.getBean("userDao");
        System.out.println(dao);

        app.close();
    }

从容器的加载到对象的创建，初始化，容器销毁，bean销毁

spring bean的创建，生命周期

1. 初探spring

2. spring bean的创建

3. bean的生命周期

猜你喜欢