Spring框架介绍及使用（一）

2023-05-16

文章目录

- 概念
- 为什么要用？
- Spring的体系结构
- Spring框架之控制反转（IOC）
- - 概念
  - Spring文件包解释
  - 入门程序
  - - 入门程序需要的jar包
    - 配置文件
    - 入门程序的建立
    - ApplicationContext与BeanFactory的区别
  - Bean的装配
  - - 默认装配方式
    - 动态工厂的错误使用
    - 动态工厂的正确使用
    - - 静态工厂
  - Bean的作用域
  - Bean后处理器
  - - 概念
    - 使用方法
    - 示例代码
    - Bean后处理器增强类中方法的功能
    - 指定增强指定的方法
  - 定制Bean的生命周期始末
  - - 实现方法
    - 示例代码
  - Bean的生命周期

概念

Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EE full-stack(一栈式) 轻量级开源框架。Spring的核心是控制反转（IOC）以及面向切面（AOC）。

为什么要用？

解耦，简化开发（高内聚低耦合）
Spring可以看作一个大工厂，统一管理和维护所有对象，属性，关系等。Spring的Bean由工厂生成。
事务处理的支持
通过简单的配置就能实现事务管理，无需手动配置，方便程序扩展
方便测试
Spring对Junit4的支持可以通过注解更方便的进行测试
可以集成其他优秀框架
可以单用Spring进行开发，同时Spring也支持使用各种优秀框架。（Mybatis，Hibernate等）
AOP编程
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能

Spring的体系结构

Spring体系结构

Spring框架之控制反转（IOC）

概念

Spring中IOC可以解决主业务耦合的问题，程序中使用的核心对象，不需要像以前那样NEW（），Spring的容器给我们创建。

Spring文件包解释

enter description here

入门程序

入门程序需要的jar包

四个核心包

beans.jar
core.jar
context.jar
springexpression .jar

3个依赖包

logging.jar
log4j.jar(不显示日志信息可以不加)
junit.jar

配置文件

位置：任意，一般存放在src
名称：任意，一般使用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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 
        <bean> 配置需要创建的对象
            id ：用于之后从spring容器获得实例时使用的
            class ：需要创建实例的全限定类名
    -->
    <bean id="..." class="..." />
</beans>

入门程序的建立

注意：为了方便截取代码，我的每个packge都放了一个对应的配置文件，所以在测试代码中，path路径为packge里的路径。如果放在src中，就不用写包的路径了。
SomeService.java：

public interface SomeService {
	void doSome();
}

SomeServiceImpl.java：

public class SomeServiceImpl implements SomeService {
	@Override
	public void doSome() {
		System.out.println("gogogogogogogogo");
	}
}

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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 默认方法 -->    
	<bean id="someService" class="com.woniuxy.spring01.SomeServiceImpl"/>
</beans>

SpringText.java：创建Bean默认方式

public void test01() {
		//底层使用的技术，dom4j解析XML,反射，工厂模式
		//对象的创建交给Spring容器，不需要new
		String path="com/woniuxy/spring01/applicationContext.xml";
		ApplicationContext ac=new ClassPathXmlApplicationContext(path);
		SomeService someService=(SomeService) ac.getBean("someService");
		someService.doSome();	
	}

==SpringText.java：使用IO创建 ==

public void test02() {
		//注意这里是文件系统IO的路径规范
		String path="D:\\cdoe\\SpringText\\src\\com\\woniuxy\\spring01\\applicationContext.xml";
		ApplicationContext fc=new FileSystemXmlApplicationContext(path);
		SomeService someService = (SomeService) fc.getBean("someService");
		someService.doSome();
	}

==SpringText.java：使用已经废弃的Beanfactory创建Bean ==

public void test03() {
		//使用Beanfactory
		String path="com/woniuxy/spring01/applicationContext.xml";
		XmlBeanFactory bf = new XmlBeanFactory(new ClassPathResource(path));
		SomeService someService=(SomeService) bf.getBean("someService");
		someService.doSome();	
	}

ApplicationContext与BeanFactory的区别

ApplicationContext在容器初始化的时候，会将所有的bean对象创建。优点是：:第一次请求响应速度块。缺点是：过多的销毁和占用系统资源
BeanFactory在调用getBean()方法，获取对象时才会创建，缺点是第一次会惩罚。

Bean的装配

默认装配方式

public void test01() {
		String path="com/woniuxy/spring01/applicationContext.xml";
		ApplicationContext ac=new ClassPathXmlApplicationContext(path);
		SomeService someService=(SomeService) ac.getBean("someService");
		someService.doSome();	
	}

动态工厂的错误使用

创建工厂类：SomeServiceFactory.java

public class SomeServiceFactory {
	public SomeService getSomeService() {
		return new SomeServiceImpl();
	}
}

applicationContext.xml：

<bean id="someService" class="com.woniuxy.spring01.SomeServiceImpl"/>
<bean id="factory" class="com.woniuxy.spring01.SomeServiceFactory"/>

SpringText.java：

public void test04() {
		//动态工厂错误使用
		String path="com/woniuxy/spring01/applicationContext.xml";
		//获取容器
		ApplicationContext fc = new ClassPathXmlApplicationContext(path);
		//从容器中获得对象
		SomeServiceFactory someServiceFactory=(SomeServiceFactory) fc.getBean("factory");
		//调用方法
		someServiceFactory.getSomeService().doSome();
		//注意：这是一个错误用法，将工厂当成了一个普通Bean来使用，不但没有解耦，反而使结构更复杂
	}

动态工厂的正确使用

创建工厂类：SomeServiceFactory.java

public class SomeServiceFactory {
	public SomeService getSomeService() {
		return new SomeServiceImpl();
	}
}
applicationContext.xml：

```xml
<!-- 动态工厂 -->
	<bean id="someService" factory-bean="factory" factory-method="getSomeService"/>
	<bean id="factory" class="com.woniuxy.spring01.SomeServiceFactory"/>

SpringText.java：

public void test05() {
		//动态工厂正确使用
		String path="com/woniuxy/spring01/applicationContext.xml";
		ApplicationContext fc = new ClassPathXmlApplicationContext(path);
		SomeService service = (SomeService) fc.getBean("someService");
		service.doSome();
	}

静态工厂

创建工厂类：SomeServiceFactory.java

public class SomeServiceFactory {
	public staic SomeService getSomeService() {
		return new SomeServiceImpl();
	}
}
applicationContext.xml：

```xml
<!-- 静态工厂 -->
	<bean id="someService" class="com.woniuxy.spring01.SomeServiceFactory" factory-method="getSomeService"/>

SpringText.java：

public void test06() {
		//静态工厂
		String path="com/woniuxy/spring01/applicationContext.xml";
		ApplicationContext fc = new ClassPathXmlApplicationContext(path);
		SomeService service = (SomeService) fc.getBean("someService");
		service.doSome();
	}

Bean的作用域

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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- scope="singleton":单例设计模式 -->
    <!-- scope="prototype":原型设计模式 -->
	<bean id="someService" class="com.woniuxy.spring01.SomeServiceImpl" scope="prototype"/>
</beans>

SpringText.java:

public void test01() {
		//测试原型模式下输出ture or false
		String path="com/woniuxy/spring01/applicationContext.xml";
		ApplicationContext ac=new ClassPathXmlApplicationContext(path);
		SomeService someService1=(SomeService) ac.getBean("someService");
		SomeService someService2=(SomeService) ac.getBean("someService");
		System.out.println(someService1==someService2);	
	}

Bean后处理器

概念

AOP的底层实现和他有关
AOP就是增强:底层使用动态代理或者cglib
Bean后处理器是一个特殊的bean。

使用方法

自定义一个类，实现bean后处理器的接口–BeanPostProcessor，容器中配一个该类的一个bean,这个bean不需要id,容器中的bean对象在创建时都会自动执行bean后处理器中的两个方法。

示例代码

MyBeanPostProcessor.java类：

public class MyBeanPostProcessor implements BeanPostProcessor{
	//bean:当前容器初始化的bean对象
	//beanname：当前bean对象的name
	//增强当前对象，返回值就是当前对象增强之后的对象
	//如果只是做日志记录操作，不增强该对象的功能，不能返回NULL，直接返回原来的bean
	@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;
	}
}

applicationContext.xml：

<bean id="someService" class="com.woniuxy.spring01.SomeServiceImpl" scope="singleton"/>
	<bean class="com.woniuxy.spring01.MyBeanPostProcessor"/>

SpringText.java：

public void test01() {
		String path="com/woniuxy/spring01/applicationContext.xml";
		ApplicationContext ac=new ClassPathXmlApplicationContext(path);
		SomeService someService=(SomeService) ac.getBean("someService");
		someService.doSome();
	}

测试结果：
enter description here

Bean后处理器增强类中方法的功能

只需要对MyBeanPostProcessor.java类进行修改即可

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("对象初始化完毕执行");
		Object stongBean = Proxy.newProxyInstance(bean.getClass().getClassLoader(), 
				bean.getClass().getInterfaces(),
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						//相当于交叉业务--切面
						System.out.println("前置增强");
						Object obj = method.invoke(bean, args);
						System.out.println("后置增强");
						return obj;
					}
				});
		return stongBean;
	}
}

测试结果：
enter description here

指定增强指定的方法

public class MyBeanPostProcessor implements BeanPostProcessor{
	//bean:当前容器初始化的bean对象
	//beanname：当前bean对象的name
	//增强当前对象，返回值就是当前对象增强之后的对象
	//如果只是做日志记录操作，不增强该对象的功能，不能返回NULL，直接返回原来的bean
	@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("对象初始化完毕执行");
		Object stongBean = Proxy.newProxyInstance(bean.getClass().getClassLoader(), 
				bean.getClass().getInterfaces(),
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						//判断增强的方法
						if(method.getName().equals("doSome")) {
							System.out.println("前置增强");
							Object obj = method.invoke(bean, args);
							System.out.println("后置增强");
							return obj;
						}else {
							Object obj = method.invoke(bean, args);
							return obj;
						}
					}
		return stongBean;
		});
	}
}

定制Bean的生命周期始末

实现方法

在实现类中定义初始化执行的方法，销毁执行的方法，绑定到配置文件中即可。

示例代码

SomeServiceImpl.java：

public class SomeServiceImpl implements SomeService {
	
	public void setUp(){
		System.out.println("初始化成功");
	}
	public void setDown(){
		System.out.println("即将销毁");
	}
	@Override
	public void doSome() {
		System.out.println("gogogogogogogogo");
	}
}

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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="someService" class="com.woniuxy.spring01.SomeServiceImpl"
		init-method="setUp"  destroy-method="setDown" />
	<bean class="com.woniuxy.spring01.MyBeanPostProcessor"/>
</beans>

测试结果：
enter description here

Bean的生命周期

Spring框架中Bean的生命周期比较复杂，一共有11个阶段。

构造器
属性赋值（set）
实现BeanNameAware，知道配置文件中，ID值。
实现BeanFactoryAware，找到Bean的创建工厂
Bean后处理器中Bean初始化执行之前方法—创建类，实现BeanPostProcessor接口。
实现InitializingBean，正在初始化Bean。
Setup—初始化完毕
Bean后处理器中Bean初始化完成之后方法—创建类，实现BeanPostProcessor接口。
执行主业务方法。
实现disposableBean接口，Bean销毁之前
teardown—对象销毁之后

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Spring

框架介绍及使用