spring架构
Spring 最初的目标就是要整合一切优秀资源,然后对外提供一个统一的服务。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式（bean可以看成是一个黑盒子，即只需要知道其功能而不必知道其内部构造和设计。）
Spring的本质是管理软件中的对象，即创建对象和维护对象之间的关系
IOC（Inversion of Control），控制反转。
所谓的控制反转，就是指将对象的创建，对象的存储(map)，对象的管理(依赖查找,依赖注入)交给了spring容器。
（spring容器是spring中的一个核心模块，用于管理对象）
在此之前，当需要对象时，通常是利用new关键字创建一个对象：
//1.创建一个Hello对象
Hello hello = new Hello();
//2.调用hello对象的方法
hello.sayHi();
而使用spring框架，对象的创建可以交给spring来做：
//1.从spring容器中获取bean对象(而不是自己new)
Hello hello = (Hello) ac.getBean("hello");
//2.调用hello对象的方法
hello.sayHi();
只需要将类提前配置在spring配置文件中，就可以将对象的创建交给spring容器，当需要对象时，不需要自己创建，而是直接通过spring获取即可，省去了new对象，可以降低代码之间的耦合性。
什么是耦合性？ <系统和系统之间的联系的复杂程度>
所谓的耦合指的是在软件开发中，在层与层之间产生了某种紧密的关系。
这种关系可能会导致，在我们修改或者是替换某一层时会影响其他的层，像这种情况我们就称之为层与层之间产生了耦合。
由于耦合（层与层之间的紧密关系）可能会导致我们在修改某一层时影响到其他的层，
而这严重违反了我们对软件进行分层的最初设想
软件各层之间应该相互独立、互不干扰，在修改或者是替换某一层时，应该做到不影响其他层。
创建maven java工程如图
1.1 引入spring的jar包：在maven工程的pom.xml文件中添加如下配置：
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tokay</groupId>
<artifactId>day16_spring</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- 集中定义依赖版本号 -->
<properties>
<junit.version>4.10</junit.version>
<spring.version>4.1.3.RELEASE</spring.version>
</properties>
<dependencies>
<!-- 单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
</project>
1.2创建spring核心配置文件—applicationContext.xml
并配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
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-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
<!--此处添加要配置的bean-->
</beans>
创建User类提供属性以及set，get 方法 以及 无参，有参构造函数 并在application中配置
UserInfo 类：
package com.tokay.pojo;
public class UserInfo {
private String name;
private String sex;
private String bir;
@Override
public String toString() {
return "UserInfo [name=" + name + ", sex=" + sex + ", bir=" + bir + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getBir() {
return bir;
}
public void setBir(String bir) {
this.bir = bir;
}
}
User类
package com.tokay.pojo;
public class User {
private String name;
private Integer age;
private UserInfo info; //这里是将UserInfo类型的 info对象的实例
//定义为 User类的成员变量（属性）
public User() {}
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
public User(String name, Integer age, UserInfo info) {
this.name = name;
this.age = age;
this.info = info;
}
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 UserInfo getInfo() {
return info;
}
public void setInfo(UserInfo info) {
this.info = info;
}
@Override
public String toString() {
return "User [name=" + name
+ ", age=" + age
+ ", info=" + info + "]";
}
}
1.在applicationContext.xml中声明User类的bean实例
<bean id="user" class="com.tokay.pojo.User"> </bean>
//singleton：单实例，是默认值。这个作用域标识的对象具备全局唯一性
<bean id="user" scope="singleton" class="com.tokay.pojo.User"> </bean>
//prototype：多实例。这个作用域标识的对象每次获取都会创建新的对象。
<bean id="user" scope="prototype" class="com.tokay.pojo.User"> </bean>
2.修改applicationContext.xml中User实例的声明为User实例注入属性
(1).Set方式注入
<bean id="user" class="com.tokay.pojo.User">
<property name="name" value="马云"/>
<property name="age" value="30"/>
<property name="info" ref="userInfo"/>
</bean>
(2).构造方法注入（spring大都使用这种方式）
<bean id="user" class="com.tokay.pojo.User">
<constructor-arg name="name" value="Tokay" />
<constructor-arg name="age" value="23" />
<constructor-arg name="info" ref="userInfo" />
</bean>
<!-- 将User类声明在spring容器中, 由spring 容器创建该类的对象 声明的User类的对象默认的单例的 如果要改为多实例, 通过scope属性设置
即可: singleton(默认值,单实例) prototype(多实例)
<!-- 将UserInfo对象的创建也交给spring容器 -->
<bean id="userInfo" class="com.tokay.pojo.UserInfo">
<property name="name" value="网易" />
<property name="sex" value="男" />
<property name="bir" value="2019" />
</bean>
TestSpring测试类
package com.tokay.test;
import javax.jws.soap.SOAPBinding.Use;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tokay.pojo.User;
public class TestSpring {
/**
* 通过Spring容器创建User类的对象 1.在Spring配置文件中声明User类的 没有配置文件就先配置
* 2.在程序中通过spring容器获取User类的对象
*/
@Test
public void testIOC() {
// 1读取Spring的核心配置文件
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
// 2获取User类的对象
// Object u = ac.getBean("user");
User u = (User) ac.getBean("user");
System.out.println(u); // com.tokay.pojo.User@52a86356
// User [name=Tokay, age=23, info=UserInfo [name=网易, sex=男, bir=2019]]
System.out.println("==============================");
User u1 = (User) ac.getBean("user");
User u2 = (User) ac.getBean("user");
if (u1 == u2) {
// <bean id="hello" scope="singleton"
// class="com.tedu.spring.Hello"></bean>
System.out.println("当前实例为单实例...");
} else {
// <bean id="hello" scope="prototype"
// class="com.tedu.spring.Hello"></bean>
System.out.println("当前实例为多实例...");
}
}
@Test
public void TestIOCProtote() throws Exception {
ClassPathXmlApplicationContext ca = new ClassPathXmlApplicationContext("applicationContext.xml");
User u = (User) ca.getBean("user");// 强制类型转换
System.out.println(u);// User [name=Tokay, age=23, info=UserInfo
// [name=网易, sex=男, bir=2019]]
}
}
小结：
Spring会自动接管每个bean定义里的property元素定义。Spring会在执行无参数的构造器后、创建默认的bean实例后，调用对应的setter方法为程序注入属性值。property定义的属性值将不再由该bean来主动创建、管理，而改为被动接收Spring的注入。
每个bean的id属性是该bean的惟一标识，程序通过id属性访问bean，bean与bean的依赖关系也通过id属性完成。