Spring入门学习

  |   0 评论   |   0 浏览



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")
  1. 文件系统路径获得配置文件
ApplicationContext context = new FileSystemXmlApplicationContext("
/home/nianshao/IdeaProjects/Test02/SpringTest01/src/beans.xml
")
  1. 使用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);
    }

}

运行结果:

KEhm5Q.png

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

标题:Spring入门学习
作者:gitsilence
地址:https://blog.lacknb.cn/articles/2019/07/20/1577974162131.html