spring 技术架构图 spring框架是什么

01. Spring框架概述

1、spring 概述

Spring 是一个2003 年兴起的，开源的、轻量级的，非侵入式的一站式的框架。

**轻量级：**核心包非常小

非侵入式：也不代码不会出现框架代码

一站式：提供控制层 SpringMVC ，提供数据访问层 jdbc，事务管理。

Spring 为简化企业级（JavaEE）应用开发而生。

Spring 是一个 设计层面的框架，他解决的业务逻辑层和其他各层松耦合问题，因此它将面向接口的

编程思想贯彻在整个系统应用中。

2、spring 的核心

控制反转（IOC）和面向切面（AOP）

它是一个容器框架，用来装javabean（java对象），中间层框架（万能胶）可以起一个连接作用，比如可以管理其他框架。

将程序中用到的对象同意交给spring框架管理

把控制生成对象的权利,反转给spring框架,

依赖注入

3、Spring 体系结构

4、Spring 项目的搭建

（1）创建Maven 项目

（2）Maven导入spring核心基础jar，在pom.xml文件中添加

<dependencies>
	  	<!-- spring-context -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>5.2.2.RELEASE</version>
	</dependency>
  </dependencies>

（3）编写spring配置文件application.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">
 	
 	<!-- 
 		控制反转：IOC  将创建对象的权力，反转给spring框架
 		id:生成对象的名称
 		class:需要spring管理的类的地址（全类名）
 	 -->
 	<bean  id="user" name="user1,user2" class="com.company.springPro.bean.UserPo"> </bean>
	
</beans>

（4）编写 UserPo 实体类

package com.company.springPro.bean;

public class UserPo {
	private String name;
	private int age;
	
	public UserPo() {
		// TODO Auto-generated constructor stub
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "UserPo [name=" + name + ", age=" + age + "]";
	}	
}

（5）测试 Test.java

package com.company.springPro.test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.company.springPro.bean.UserPo;

import junit.framework.TestCase;

public class Test extends TestCase{
	public void testStart() {
		
		//启动spring 		加载spring的配置文件，创建一个ApplicationContext
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
		
		//参数user是在application.xml配置文件中bean对应的id
		UserPo user = (UserPo)applicationContext.getBean("user");
		System.out.println(user);
		UserPo user1 = (UserPo)applicationContext.getBean("user1");
		System.out.println(user1);
		UserPo user2 = (UserPo)applicationContext.getBean("user2");
		System.out.println(user2);
	}
}

结果：

com.company.springPro.bean.UserPo@4e91d63f
com.company.springPro.bean.UserPo@4e91d63f
com.company.springPro.bean.UserPo@4e91d63f

根据结果，发现只创建了一次对象。原因是Bean配置中scope默认为singleton:单例的。

5、IOC本质

读作 “反转控制” (Inverse of Control)，更好理解，不是什么技术，而是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。

正控：若要使用某个对象，需要自己去负责对象的创建

反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架。

简单一句话：就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。

原理：

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

这个过程就叫控制反转 :

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的 .

反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

6、Spring配置

6.1 Bean 配置

（1）id：生成对象的名称

（2）class：需要spring管理的类的地址（全类名）

（3）name：相当于别名，可以为多个，中间逗号隔开

（4）scope：控制生成对象的方式

prototype: 原型的. 每次调用 getBean 方法都会返回一个新的 bean. 且在第一次调用 getBean 方法时才创建实例。

singleton: 单例的. 每次调用 getBean 方法都会返回同一个 bean. 且在 IOC 容器初始化时即创建 bean 的实例. 默认值 singleton

示例：

<bean  id="user" name="user1,user2" class="com.company.springPro.bean.UserPo" scope="prototype"> </bean>

6.2 import 导入其它配置文件

<!-- 导入其他spring配置文件 -->
<import resource="bean.xml"/>

7、依赖注入

7.1 属性注入

Bean类：UserPo.java

package com.company.springPro.bean;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class UserPo {
	private String name;
	private int age;
	private DeptPo dept;
	private List list;
	private Set set;
	private Map map;
	private Properties properties;
	
	public UserPo() {
		// TODO Auto-generated constructor stub
	}	

	public UserPo(String name, int age, DeptPo dept) {
		super();
		this.name = name;
		this.age = age;
		this.dept = dept;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public DeptPo getDept() {
		return dept;
	}

	public void setDept(DeptPo dept) {
		this.dept = dept;
	}	

	public List getList() {
		return list;
	}

	public Set getSet() {
		return set;
	}

	public Properties getProperties() {
		return properties;
	}

	public void setList(List list) {
		this.list = list;
	}

	public void setSet(Set set) {
		this.set = set;
	}

	public void setProperties(Properties properties) {
		this.properties = properties;
	}

	public Map getMap() {
		return map;
	}

	public void setMap(Map map) {
		this.map = map;
	}

	@Override
	public String toString() {
		return "UserPo [name=" + name + ", age=" + age + ", dept=" + dept + ", list=" + list + ", set=" + set + ", map="
				+ map + ", properties=" + properties + "]";
	}
}

application.xml

<!-- 属性注入 -->
 	  <bean id="user" class="com.company.springPro.bean.UserPo">
 	  	<property name="age" value="100"/>
 	  	<property name="name" value="张三" />
 	  	<property name="properties">
 	  		<props>
 	  			<prop key="p1">dept</prop>
 	  		</props>
 	  	</property>
 	  	<property name="list">
 	  		<list>
 	  			<value>1</value>
 	  			<value>2</value>
 	  			<value>3</value>
 	  		</list>
 	  	</property>
 	  	<property name="set">
 	  		<set>
 	  			<value>4</value>
 	  			<value>5</value>
 	  			<value>6</value>
 	  		</set>
 	  	</property>
 	  	<property name="map">
 	  		<map>
 	  			<entry key="key1" value="7"></entry>
 	  			<entry key="key2" value="8"></entry>
 	  			<entry key="key3" value-ref="dept"></entry>
 	  		</map>
 	  	</property>
 	  	
 	  <bean id="dept" class="com.company.springPro.bean.DeptPo">
 	  	<property name="num" value="10"></property>
 	  </bean>

7.2 构造方法注入

<!-- 构造方法注入 -->
 	  <bean id="user2" class="com.company.springPro.bean.UserPo">
 	  	<constructor-arg type="java.lang.String" value="李四" />
 	  	<constructor-arg type="int" value="18" />
 	  	<constructor-arg type="DeptPo" ref="dept" />
 	  </bean>