gitsilence 的个人博客

1. 编写流程

• 下载Spring的开发包
  下载地址： 点击跳转
• 导入Spring的jar包

• 配置Spring的核心xml文件
• 在程序中读取Spring的配置文件来获取Bean【Bean其实就是一个new好的对象】

spring-core-5.0.2.RELEASE.jar

包含Spring框架基本的核心工具类，Spring其他组件都要使用这个包里的类，是其他组件的核心

spring-beans-5.0.2.RELEASE.jar

所有应用都要用到的，它包含访问配置文件、创建和管理Bean，以及进
行Inversion of Control(Ioc)/Dependency Injection(DI)操作相关的
所有类

spring-context-5.0.2.RELEASE.jar

  Spring提供在基础IoC功能上的扩展服务，此外还提供许多企业级服务的
  支持，如邮件服务、任务调度、JNDI定位、EJB集成、远程访问、缓存以
  及各种视图层框架的封装等。

spring-expression-5.0.2.RELEASE.jar

  Spring表达式语言

commons-logging-1.2.jar

  第三方的，主要用于处理日志

• 写个配置文件beans.xml 在src根目录下 模板在下面

<?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 definitions here -->

</beans>

例子

• 创建一个UserService接口

package com.spring;
public interface UserService {
    public void add();
}

• 创建一个实现类实现add方法 UserImpl

package com.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class UserImpl implements UserService {
    public void add() {
        System.out.println("添加用户....");
    }
    public static void main(String[] args) {
        // 以前的运行方式
        //UserService add = new UserImpl();
       // add.add();
        // 现在的运行方式
        // 使用UserService方式从spring容器中获取
        // 1. 加载配置文件beans.xml 内部就会创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        // 2. 从spring容器获取UserService对象
        UserImpl add = (UserImpl) context.getBean("userService");  
        // 这里的字符串是beans.xml文件中的id
        add.add();
	}
}

• beans.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 definitions here -->
    <!-- bean in here -->
    <bean id="userService" class="com.spring.UserImpl"></bean>
</beans>

spring内部创建对象的原理：
	1. 解析xml文件，获取类名、id属性
	2. 通过反射，用类型创建对象
	3. 给创建的对象赋值

加载spring容器的三种方式

1. 类路径获得配置文件

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
// 如果是放在包内
// new ClassPathXmlApplicationContext("com/spring/beans.xml")

2. 文件系统路径获得配置文件

ApplicationContext context = new FileSystemXmlApplicationContext("
/home/nianshao/IdeaProjects/Test02/SpringTest01/src/beans.xml
")

3. 使用BeanFactory(了解)

String path = "/home/nianshao/IdeaProjects/Test02/SpringTest01/src/beans.xml";
BeanFactory factory = new XmlBeanFactory(new FileSystemResource(path));
UserImpl add = (UserImpl) factory.getBean("userService");  

多配置文件的使用

• 当开发的项目较大时，使用一个spring配置文件是比较复杂的
  其中可能具有几千行的配置信息，在其中查找某一个Bean对象的配
  置是非常困难的。所以在spring中可以定义多个配置文件，将一类
  配置放在一个文件中。
  例如：

ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml", "applicationContext-part2.xml"});

BeanFactory与Application对比

• BeanFactory采取延迟加载，第一次getBean时才会初始化Bean
• ApplicationContext采用即时加载，是对BeanFactory的扩展，
  提供了更多的功能

* 国际化处理
* 事件传递
* Bean自动装配
* 各种不同应用层的Context实现

装配Bean的三种方式， 所谓的装配Bean就是在xml文件中写一个bean标签

• 构造方法实例化Bean

  • 创建BeanClass.java

    package cn.lacknb.instance;
    
    public class BeanClass {
    
        public String message;
    
        public BeanClass(){
            message = "构造方法实例化";
        }
    
        public BeanClass(String s){
            message = s;
        }
    
    }
    
    

  • 编辑配置文件

    <!-- 构造方法实例化Bean--> <bean id="constructorInstance" class="cn.lacknb.instance.BeanClass" />

• 静态工厂方法实例化Bean

  • 创建BeanStaticFactory.java

    package cn.lacknb.instance;
    
    public class BeanStaticFactory {
    
        private static BeanClass beanInstance = new BeanClass("调用静态工厂方法实例化Bean");
        public static BeanClass createInstance(){
            return beanInstance;
        }
    
    }
    
    

  • 编辑配置文件

    <!-- 静态工厂实例化--> <bean id="staticFactoryInstance" class="cn.lacknb.instance.BeanStaticFactory" factory-method="createInstance"/>

• 测试实例工厂方法实例化Bean

  • 创建BeanInstanceFactory.java

    package cn.lacknb.instance;
    
    public class BeanInstanceFactory {
    
        public BeanClass createBeanClassInstance(){
            return new BeanClass("调用实例工厂方法实例化Bean");
        }
    }
    
    

  • 编辑配置文件

    <!-- 配置工厂--> <bean id="myFactory" class="cn.lacknb.instance.BeanInstanceFactory"/><!-- 使用factory-bean属性指定配置工厂,使用factory-method属性指定使用工厂中的哪个方法实例化Bean--> <bean id="instanceFactoryInstance" factory-bean="myFactory" factory-method="createBeanClassInstance" />

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="constructorInstance" class="cn.lacknb.instance.BeanClass" />
<!--    静态工厂实例化-->
    <bean id="staticFactoryInstance" class="cn.lacknb.instance.BeanStaticFactory" factory-method="createInstance"/>

<!--    配置工厂-->
    <bean id="myFactory" class="cn.lacknb.instance.BeanInstanceFactory"/>
<!--    使用factory-bean属性指定配置工厂,使用factory-method属性指定使用工厂中的哪个方法实例化Bean-->
    <bean id="instanceFactoryInstance" factory-bean="myFactory" factory-method="createBeanClassInstance" />
</beans>

测试类汇总:

package cn.lacknb.Test;

import cn.lacknb.instance.BeanClass;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestInstance {


    public static void main(String[] args) {
        // 初始化Spring容器 ApplicationContext, 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("xml/beans01.xml");
        // 测试构造方法 实例化bean
        BeanClass b1 = (BeanClass) context.getBean("constructorInstance");
        System.out.println(b1 + b1.message);
        // 测试静态工厂方法实例化Bean
        BeanClass b2 = (BeanClass) context.getBean("staticFactoryInstance");
        System.out.println(b2 + b2.message);
        // 测试实例工厂方法实例化Bean
        BeanClass b3 = (BeanClass) context.getBean("instanceFactoryInstance");
        System.out.println(b3 + b3.message);
    }

}

运行结果:

Bean的生命周期

1. instantiate bean对象实例化
2. populate properties封装属性
3. 如果Bean实现BeanNameAware 执行setBeanName
4. 如果Bean实现BeanFactoryAware 执行setBeanFactory， 获取容器
5. 如果存在类实现BeanPostProcessor (后处理Bean)，执行postProcessBeforeInitialization
6. 如果Bean实现InitializingBean 执行afterPropertiesSet
7. 调用<bean init-method="init">执行初始化方法init
8. 如果存在类实现BeanPostProcessor(处理bean), 执行postProcessAfterInitialization 执行业务处理  
9. 如果Bean实现DisposableBean执行destroy方法  
10. 调用<bean destroy-method="cusomerDestroy"> 指定销毁方法customerDestroy