Spring 基础知识之一

女爷i 2023-10-10 11:05 6阅读 0赞

**第一：Spring概述**

Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control： 反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多 著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。

**第二：Spring 体系结构**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70][]

2.1 Spring 核心框架

核心容器由spring-core，spring-beans，spring-context，spring-context-support和spring-expression（SpEL，Spring表达式语言，Spring Expression Language）等模块组成，它们的细节如下：

1、spring-core模块提供了框架的基本组成部分，包括 IoC 和依赖注入功能。

2、spring-beans 模块提供 BeanFactory，工厂模式的微妙实现，它移除了编码式单例的需要，并且可以把配置和依赖从实际编码逻辑中解耦。

3、context模块建立在由core和 beans 模块的基础上建立起来的，它以一种类似于JNDI注册的方式访问对象。Context模块继承自Bean模块，并且添加了国际化（比如，使用资源束）、事件传播、资源加载和透明地创建上下文（比如，通过Servelet容器）等功能。Context模块也支持Java EE的功能，比如EJB、JMX和远程调用等。ApplicationContext接口是Context模块的焦点。spring-context-support提供了对第三方库集成到Spring上下文的支持，比如缓存（EhCache, Guava, JCache）、邮件（JavaMail）、调度（CommonJ, Quartz）、模板引擎（FreeMarker, JasperReports, Velocity）等。

4、spring-expression模块提供了强大的表达式语言，用于在运行时查询和操作对象图。它是JSP2.1规范中定义的统一表达式语言的扩展，支持set和get属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从Spring IoC容器检索对象，还支持列表的投影、选择以及聚合等。

2.2 Spring 模块之间的依赖关系

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 1][]

2.4 Spring 数据连接/集成模块

数据访问/集成层包括 JDBC，ORM，OXM，JMS 和事务处理模块，它们的细节如下：（注：JDBC=Java Data Base Connectivity，ORM=Object Relational Mapping，OXM=Object XML Mapping，JMS=Java Message Service）

1、JDBC 模块提供了JDBC抽象层，它消除了冗长的JDBC编码和对数据库供应商特定错误代码的解析。

2、ORM 模块提供了对流行的对象关系映射API的集成，包括JPA、JDO和Hibernate等。通过此模块可以让这些ORM框架和spring的其它功能整合，比如前面提及的事务管理。

3、OXM 模块提供了对OXM实现的支持，比如JAXB、Castor、XML Beans、JiBX、XStream等。

4、JMS 模块包含生产（produce）和消费（consume）消息的功能。从Spring 4.1开始，集成了spring-messaging模块。。

5、事务模块为实现特殊接口类及所有的 POJO 支持编程式和声明式事务管理。（注：编程式事务需要自己写beginTransaction()、commit()、rollback()等事务管理方法，声明式事务是通过注解或配置由spring自动处理，编程式事务粒度更细）

2.5 Spring Web

Web 层由 Web，Web-MVC，Web-Socket 和 Web-Portlet 组成，它们的细节如下：

1、Web 模块提供面向web的基本功能和面向web的应用上下文，比如多部分（multipart）文件上传功能、使用Servlet监听器初始化IoC容器等。它还包括HTTP客户端以及Spring远程调用中与web相关的部分。。

2、Web-MVC 模块为web应用提供了模型视图控制（MVC）和REST Web服务的实现。Spring的MVC框架可以使领域模型代码和web表单完全地分离，且可以与Spring框架的其它所有功能进行集成。

3、Web-Socket 模块为 WebSocket-based 提供了支持，而且在 web 应用程序中提供了客户端和服务器端之间通信的两种方式。

4、Web-Portlet 模块提供了用于Portlet环境的MVC实现，并反映了spring-webmvc模块的功能。

2.6 Spring 其他

其他一些重要的模块，像 AOP，Aspects，Instrumentation，Web 和测试模块，它们的细节如下：

1、AOP 模块提供了面向方面的编程实现，允许你定义方法拦截器和切入点对代码进行干净地解耦，从而使实现功能的代码彻底的解耦出来。使用源码级的元数据，可以用类似于.Net属性的方式合并行为信息到代码中。

2、Aspects 模块提供了与 AspectJ 的集成，这是一个功能强大且成熟的面向切面编程（AOP）框架。

3、Instrumentation 模块在一定的应用服务器中提供了类 instrumentation 的支持和类加载器的实现。

4、Messaging 模块为 STOMP 提供了支持作为在应用程序中 WebSocket 子协议的使用。它也支持一个注解编程模型，它是为了选路和处理来自 WebSocket 客户端的 STOMP 信息。

5、测试模块支持对具有 JUnit 或 TestNG 框架的 Spring 组件的测试。

**第三：Spring 开发环境搭建(Spring IOC开发环境搭建)**

3.1 Spring 依赖jar 如下：

<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context</artifactId>
    			<version>5.0.2.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-core</artifactId>
    			<version>5.0.2.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-beans</artifactId>
    			<version>5.0.2.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-expression</artifactId>
    			<version>5.0.2.RELEASE</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>log4j</groupId>
    			<artifactId>log4j</artifactId>
    			<version>1.2.16</version>
    		</dependency>
    		<dependency>
    			<groupId>commons-logging</groupId>
    			<artifactId>commons-logging</artifactId>
    			<version>1.2</version>
    		</dependency>

3.2 持久层和业务层代码编写：

package com.zzg.spring.dao;
    
    /**
     * 账户持久层接口
     * @author Administrator
     *
     */
    public interface IAccountDao {
    	/**
    	 * 账户保存
    	 */
    	void saveAccount();
    }
    
    
    package com.zzg.spring.dao.impl;
    
    import com.zzg.spring.dao.IAccountDao;
    
    /**
     * 账户持久层接口实现类
     * @author Administrator
     *
     */
    public class AccountDaoImpl implements IAccountDao {
    
    	@Override
    	public void saveAccount() {
    		// TODO Auto-generated method stub
    		System.out.println("账户保存");
    	}
    
    }
    
    
    package com.zzg.spring.service;
    
    /**
     * 账户业务层接口
     * @author Administrator
     *
     */
    public interface IAccountService {
    	/**
    	 * 账户保存
    	 */
    	void saveAccount();
    }
    
    
    package com.zzg.spring.service.impl;
    
    import com.zzg.spring.dao.IAccountDao;
    import com.zzg.spring.service.IAccountService;
    
    /**
     * 账户业务层接口实现类
     * @author Administrator
     *
     */
    public class AccountServiceImpl implements IAccountService {
    	// 注入持久层dao
    	private IAccountDao dao;
    	
    	public IAccountDao getDao() {
    		return dao;
    	}
    
    	public void setDao(IAccountDao dao) {
    		this.dao = dao;
    	}
    
    	@Override
    	public void saveAccount() {
    		// TODO Auto-generated method stub
    		dao.saveAccount();
    	}
    
    }

3.3 配置文件和测试功能代码

package com.zzg.spring;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.zzg.spring.service.IAccountService;
    
    public class Client {
    
    	public static void main(String[] args) {
    		//1.使用 ApplicationContext 接口，就是在获取 spring 容器
    		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    		//2.根据 bean 的 id 获取对象
    		IAccountService aService = (IAccountService) ac.getBean("service");
    		aService.saveAccount();
    	}
    
    }

**第四:Spring IOC 中Bean标签**

4.1 Bean 标签作用：

用于配置对象让 spring 来创建的。  
默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

4.2 Bean 标签属性:

id：给对象在容器中提供一个唯一标识。用于获取对象。  
class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。  
scope：指定对象的作用范围。  
\* singleton :默认值，单例的.  
\* prototype :多例的.  
\* request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.  
\* session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.  
\* global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.  
init-method：指定类中的初始化方法名称。  
destroy-method：指定类中销毁方法名称。

4.3 Bean的三种实例化方式

4.3.1 使用默认无参构造函数

<bean id="dao" class="com.zzg.spring.dao.impl.AccountDaoImpl"/>

4.3.2 spring 管理静态工厂-使用静态工厂的方法创建对象

package com.zzg.spring.factory;
    
    import com.zzg.spring.service.IAccountService;
    import com.zzg.spring.service.impl.AccountServiceImpl;
    /**
     * spring 静态工程方法
     * @author Administrator
     *
     */
    public class StaticFactory {
    	public static IAccountService createAccountService(){
    		return new AccountServiceImpl();
    		}
    }

<?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="dao" class="com.zzg.spring.dao.impl.AccountDaoImpl" />
    
    	
    	
    
    	
    	<bean id="accountService"
    		class="com.zzg.spring.factory.StaticFactory"
    		factory-method="createAccountService"></bean>
    </beans>

package com.zzg.spring;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.zzg.spring.dao.IAccountDao;
    import com.zzg.spring.service.impl.AccountServiceImpl;
    
    public class Client {
    
    	public static void main(String[] args) {
    		//1.使用 ApplicationContext 接口，就是在获取 spring 容器
    		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    		//2.根据 bean 的 id 获取对象
    		IAccountDao dao = (IAccountDao) ac.getBean("dao");
    		
    		AccountServiceImpl service = (AccountServiceImpl) ac.getBean("accountService");
    		service.setDao(dao);
    		service.saveAccount();
    	}
    
    }

4.3.3 spring 管理实例工厂-使用实例工厂的方法创建对象

package com.zzg.spring.factory;
    
    import com.zzg.spring.service.IAccountService;
    import com.zzg.spring.service.impl.AccountServiceImpl;
    
    /**
     * spring 实例工厂方法
     * 
     * @author Administrator
     *
     */
    public class InstanceFactory {
    	public IAccountService createAccountService() {
    		return new AccountServiceImpl();
    	}
    }

<?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="dao" class="com.zzg.spring.dao.impl.AccountDaoImpl" />
    
    	
    	
    
    	
    	
    
    	
    	<bean id="instancFactory"
    		class="com.zzg.spring.factory.InstanceFactory"></bean>
    	<bean id="accountService" factory-bean="instancFactory"
    		factory-method="createAccountService"></bean>
    </beans>

package com.zzg.spring;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.zzg.spring.dao.IAccountDao;
    import com.zzg.spring.service.impl.AccountServiceImpl;
    
    public class Client {
    
    	public static void main(String[] args) {
    		//1.使用 ApplicationContext 接口，就是在获取 spring 容器
    		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    		//2.根据 bean 的 id 获取对象
    		IAccountDao dao = (IAccountDao) ac.getBean("dao");
    		
    		AccountServiceImpl service = (AccountServiceImpl) ac.getBean("accountService");
    		service.setDao(dao);
    		service.saveAccount();
    	}
    
    }

**第五:Spring 依赖注入**

5.1 Spring 依赖注入核心概念

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。  
我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。  
ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。  
那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。  
简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

5.2 Spring 依赖注入的几种方式

5.2.1 构造函数注入

使用构造函数的方式，给  bean中的属性传值 要求: 类中需要提供一个对应参数列表的构造函数。

构造函数涉及的标签(constructor-arg):

index:指定参数在构造函数参数列表的索引位置  
type:指定参数在构造函数中的数据类型

name:指定参数在构造函数中的名称

value:它能赋的值是基本数据类型和 String 类型  
ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean

示例代码:

package com.zzg.spring.entity;
    
    import java.util.Date;
    
    /**
     * 用户实体对象
     * @author Administrator
     *
     */
    public class UserEntity {
    	private String name;
    	private Integer age;
    	private Date birthday;
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public Integer getAge() {
    		return age;
    	}
    	public void setAge(Integer age) {
    		this.age = age;
    	}
    	public Date getBirthday() {
    		return birthday;
    	}
    	public void setBirthday(Date birthday) {
    		this.birthday = birthday;
    	}
    	//构造函数
    	public UserEntity(String name, Integer age, Date birthday) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.birthday = birthday;
    	}
    
    	@Override
    	public String toString() {
    		// TODO Auto-generated method stub
    		System.out.println(name+","+age+","+birthday);
    		return super.toString();
    	}
    }

package com.zzg.spring;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.zzg.spring.entity.UserEntity;
    
    public class Constructor {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//1.使用 ApplicationContext 接口，就是在获取 spring 容器
    		ApplicationContext ac = new ClassPathXmlApplicationContext("constructor.xml");
    		//2.根据 bean 的 id 获取对象
    		UserEntity entity = (UserEntity) ac.getBean("userEntity");
    		entity.toString();
    	}
    
    }

5.2.2 set方法注入

set方法涉及标签(property)：

name：找的是类中 set 方法后面的部分  
ref：给属性赋值是其他 bean 类型的  
value：给属性赋值是基本数据类型和 string 类型的

示例代码:

package com.zzg.spring.entity;
    
    import java.util.Date;
    
    /**
     * 用户实体对象
     * @author Administrator
     *
     */
    public class UserEntity {
    	private String name;
    	private Integer age;
    	private Date birthday;
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public Integer getAge() {
    		return age;
    	}
    	public void setAge(Integer age) {
    		this.age = age;
    	}
    	public Date getBirthday() {
    		return birthday;
    	}
    	public void setBirthday(Date birthday) {
    		this.birthday = birthday;
    	}
    	
    
    	@Override
    	public String toString() {
    		// TODO Auto-generated method stub
    		System.out.println(name+","+age+","+birthday);
    		return super.toString();
    	}
    	
    }

package com.zzg.spring;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.zzg.spring.entity.UserEntity;
    
    public class Constructor {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//1.使用 ApplicationContext 接口，就是在获取 spring 容器
    		ApplicationContext ac = new ClassPathXmlApplicationContext("constructor.xml");
    		//2.根据 bean 的 id 获取对象
    		UserEntity entity = (UserEntity) ac.getBean("userEntity");
    		entity.toString();
    	}
    
    }

5.2.3 注入集合属性

顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。我们这里介绍注入数组，List,Set,Map,Properties。

示例:

package com.zzg.spring.entity;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Properties;
    import java.util.Set;
    
    public class SchoolEntity {
    	private List<String> myList;
    	private Set<String> mySet;
    	private Map<String,String> myMap;
    	private Properties myProps;
    	
    	public List<String> getMyList() {
    		return myList;
    	}
    	public void setMyList(List<String> myList) {
    		this.myList = myList;
    	}
    	public Set<String> getMySet() {
    		return mySet;
    	}
    	public void setMySet(Set<String> mySet) {
    		this.mySet = mySet;
    	}
    	public Map<String, String> getMyMap() {
    		return myMap;
    	}
    	public void setMyMap(Map<String, String> myMap) {
    		this.myMap = myMap;
    	}
    	public Properties getMyProps() {
    		return myProps;
    	}
    	public void setMyProps(Properties myProps) {
    		this.myProps = myProps;
    	}
    }

<?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="school" class="com.zzg.spring.entity.SchoolEntity">
    		
    		<property name="myList">
    			<array>
    				<value>AAA</value>
    				<value>BBB</value>
    				<value>CCC</value>
    			</array>
    		</property>
    		
    		<property name="mySet">
    			<list>
    				<value>AAA</value>
    				<value>BBB</value>
    				<value>CCC</value>
    			</list>
    		</property>
    		
    		<property name="myMap">
    			<props>
    				<prop key="testA">aaa</prop>
    				<prop key="testB">bbb</prop>
    			</props>
    		</property>
    		
    		<property name="myProps">
    			<map>
    				<entry key="testA" value="aaa"></entry>
    				<entry key="testB">
    					<value>bbb</value>
    				</entry>
    			</map>
    		</property>
    	</bean>
    
    </beans>

package com.zzg.spring;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.zzg.spring.entity.SchoolEntity;
    
    public class Aggregate {
    
    	public static void main(String[] args) {
    		//1.使用 ApplicationContext 接口，就是在获取 spring 容器
    		ApplicationContext ac = new ClassPathXmlApplicationContext("aggregate.xml");
    		//2.根据 bean 的 id 获取对象
    		SchoolEntity entity = (SchoolEntity) ac.getBean("school");
    		System.out.println(String.join(",", entity.getMyList()));
    		entity.toString();
    	}
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200510235044368.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200510235428387.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70