玩转Spring——Spring入门基础

Posted 2021-12-02 ericz2j

什么是Spring
Spring是一个开源的的轻量级的应用开发框架，其目的是用来简化企业级应用程序开发，减少代码之间的侵入性。
Spring提供的IOC和AOP应用，可以将组件的耦合度将至最低，即我们常说的解耦，这样能便于日后系统的升级和维护。
Spring为系统提供了一个整体的解决方案，开发者除了可以利用它本身提供的功能外，还可以与第三方 的框架和技术整合应用，可以自由的选择采用哪种技术进行开发。

使用Spring的目的
Spring 的本质是管理软件中的对象，即如何创建对象和维护对象之间的关系。

Spring功能模块简介
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式。组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。
核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

 

Spring容器简介
在Spring中，任何java类和javaBean都会被当成Bean处理，这些Bean通过Spring容器进行管理和应用，Spring容器是实现了IOC和AOP机制，这些机制可以简化Bean的创建和Bean对象之间的解耦。
Spring容器有BeanFactory和ApplicationContext两种类型。BeanFacotry是Spring中比较原始的Factory，ApplicationContext继承自BeanFactory接口，拥有更多的企业级方法，原始的BeanFactory无法支持Spring的许多插件，如AOP功能、Web应用等， 所以在实际应用中推荐使用ApplicationContext，实例化ApplicationContext有两种方式（两种方式下都需要有applicationContext.xml配置文件）

Spring具体开发步骤
普通java项目和web项目均可使用Spring框架来开发，这里先以普通项目为例：
步骤1、先导入指定的jar包（5个，Spring 的jar版本一定要统一）
“commons-logging.jar” “spring-beans-4.2.4.RELEASE.jar”
“spring-context-4.2.4.RELEASE.jar” “spring-core-4.2.4.RELEASE.jar”
“spring-expression-4.2.4.RELEASE.jar”
步骤2、书写一个普通的实体类UserBean
步骤3、为这个实体类书写指定的配置文件applicationContext.xml
步骤4、写一个测试类获得UserBean实例

实例化ApplicationContext方式
方式一： 通过ClassPathXmlApplicationContext加载配置文件并实例化：
其默认去类路径下找配置文件 ，类路径指的就是编译后的 .class文件所在位置的路径，普通项目在bin，web项目在web-info/classes中。

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

当需要加载多个applicationContext.xml文件时可以是数组：

ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"，"ac1.xml"，”ac2.xml”});

也可以是绝对路径（需要加file前缀）：

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("file:D:/FirstSpringPJ/src/ac.xml");

方式二：通过FileSystemXmlApplicationContext加载配置文件并实例化：
其默认是去项目的路径（相对路径）下加载，也可以是绝对路径

ApplicationContext ac = new FileSystemXmlApplicationContext("src/applicationContext.xml");

加载多个配置文件时可以是数组：

ApplicationContext ac=new FileSystemXmlApplicationContext（ new String[]{"src/applicationContext.xml"}）;

绝对路径（可以省略file前缀）：

ApplicationContext ac=new FileSystemXmlApplicationContext("D:\\FirstSpring_Project\\src\\ac.xml");

Bean的实例化
1、使用构造器实例化；（90%通常使用该方法）
2、使用静态工厂方法实例化；
3、使用实例化工厂方法实例化。
每一种实例化在applicationContext.xml配置文件中配置的方式都不一样：

一、使用构造器实例化 ：

<bean id="userBean" class="first_spring.UserBean"/>

指定好标识符id或者name以及类型class以后，Spring容器会通过无参构造器来实例化该类，所以使用这个方式来实例化Bean要求要实例化的类中一定要求无参构造器

二、使用静态工厂方法实例化：

<bean id="userBean" class="first_spring.UserBeanFactory" factory-method="getInstance"></bean>

factory-method属性指是实现实例化类的静态方法。
注意使用该方法需要用到静态工厂方法 :

// 创建一个生产UserBean实例的工厂类
public class UserBeanFactory{
public static UserBean getInstance（）{ //创建静态工厂方法
return new UserBean(); // 返回实例化的类的对象
}
}

三 、使用实例化工厂方法实例化：
该方法和上面的方法不同之处在与使用该实例化方式工厂方法不需要是静态的，但是在spring的配置文件中需要配置更多的内容 。

<bean id="userBeanFactory" class="first_spring.UserBeanFactory"></bean>
<bean id="userBean" factory-bean="userBeanFactory" factorymethod="createUserBean"></bean>

其中配置的第一个bean是 先用构造器方法实例化工厂类UserBeanFactory，配置的第二个bean的factory-bean属性值和 第一个bean的 id值对应， factory-method属性 是第一bean的 实例工厂方法， 最后调用getBean() 即可。

public class UserBeanFactory{
//创建静态工厂方法
public static UserBean getInstance(){ 
return new UserBean(); // 返回实例化的类的对象
}
// 创建实例工厂方法
public UserBean createUserBean(){
return new UserBean();
}
}

示例：
1.在applicationContext.xml配置文件中，利用构造器实例化一个Person类，并通过ApplicationContext容器获取该对象，并写出关键代码。
Person类如下：

class Person{
private String name;
private String password;
private String age;
private String address;
//省略Setter和Getter方法
}

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"
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 id="person" class="com.eric.SpringTest01.Person">
<property name="name" value="Eric"></property>
</bean>
</beans>

测试类构造器实例化bean：

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) applicationContext.getBean("person");
System.out.println(person.getName());

2.在applicationContext.xml中，利用静态工厂方法实例化一个Person类，并通过ApplicationContext容器获取该对象，并写出PersonFactory对象以及关键代码。

PersonFactory类：

public class PersonFactory {
public static Person getPerson() {
return new Person();
}
}

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"
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 id="person" class="com.eric.SpringTest01.PersonFactory" factory-method="getPerson">
<property name="name" value="Eric11"></property>
</bean>

 

Spring中Bean的五个作用域
当通过Spring容器创建一个Bean实例时，不仅可以完成Bean实例的实例化，还可以为Bean指定特定的作用域。Spring支持如下5种作用域：

1. singleton：单例模式，在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例。
2. prototype：原型模式，每次通过容器的getBean方法获取prototype定义的Bean时，都将产生一个新的Bean实例。
3. request：对于每次HTTP请求，使用request定义的Bean都将产生一个新实例，即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时，该作用域才有效。
4. session：对于每次HTTP Session，用法和使用时机同上。
5. globalsession：每个全局的HTTP Session，使用session定义的Bean都将产生一个新实例。一般用于Porlet应用环境 , 分布式系统存在全局session概念。如果不是porlet环境，globalSession 等同于Session 。

一般来说 比较常用的是singleton和prototype两种作用域。用scope可以指定作用域。对于singleton作用域的Bean，每次请求该Bean都将获得相同的实例。容器负责跟踪Bean实例的状态，负责维护Bean实例的生命周期行为；如果一个Bean被设置成prototype作用域，程序每次请求该id的Bean，Spring都会新建一个Bean实例，然后返回给程序。在这种情况下，Spring容器仅仅使用new 关键字创建Bean实例，一旦创建成功，容器不在跟踪实例，也不会维护Bean实例的状态。
如果不指定Bean的作用域，Spring默认使用singleton作用域。

Spring管理下的Bean的生命周期
通过为配置文件bean定义中添加相应的init-method和destroy-method属性，可以指定Bean中的某些方法为初始化方法和销毁方法。

<bean id="mb" class="basic.MessageBean"
init-method="init" destroy-method="destroy"
scope="prototype"/>

public class MessageBean{
public MessageBean() {    }
public void init(){ System.out.println("调用初始化init()..."); }
public void destroy(){ System.out.println("调用销毁()..") }
}

 

Bean的延迟实例化
在Spring中，默认的行为是ApplicationContext在启动的时候就将所有的 singleton的Bean并缓存在容器中 虽然启动时会花费一些时间，但带来两个好处：

1. 对Bean提前实例化操作会及早发现一些潜在的配置问题；
2. Bean以缓存的方式保存，当运行期使用到该Bean的时候无需再实例化，加快运行的效率。

如果用户不希望容器启动的时候提前实例化singleton的Bean，可以通过lazy-init属性进行控制：

<bean id="userBean" class="first_spring.UserBean" lazy-init=“true”/>