Spring是分层的JavaSE/EE full-stack 轻量级开源框架,以IoC(Inverse of Control 控制反转)和AOP(Aspect Oriented Programming 面向切面编程)为内核,使用基本的JavaBean来实现程序功能。
在实际开发中,通常服务器端采用三层体系架构,分别为表示层(web)、业务逻辑层(service)、持久层(dao), Spring对每一层都提供了技术支持。
Spring具有简单、可测试和松耦合的特点,从这个角度出发,Spring不仅可以用于服务器端开发,也可以应用于任何Java应用的开发中。
Spring几大核心功能
1.IoC/DI 控制反转/依赖注入
2. AOP 面向切面编程
3 声明式事务
上图是spring框架的运行框架
一:Test
Test:是Spring提供的测试功能
二:Core Container
Core Container是核心容器,也是Spring提供的最基本的条件
包含:
1.Beans:提供Spring负责创建类对象并管理对象的功能
2.Core:核心类
3.Context:上下文参数。获取外部资源或管理注解等
4.SpEL:是一种强大的表达式语言
三:其他模块
AOP模块 :实现aop功能需要依赖。允许定义方法拦截器和切入点,将代码按照功能进行分离,以降低耦合性
Aspects模块 : 切面 AOP 依赖的包
Instrumentation模块 :提供了类工具的支持和类加载器的实现,可以在特定的应用服务器中使用
四:Data Access/INtegration(数据访问/集成)模块
JDBC模块:Spring 对 JDBC 封装后的代码。提供了一个JDBC的抽象层,大幅度地减少了在开发过程中对数据库操作的代码
ORM模块:封装了持久层框架的代码.例如 Hibernate
transactions模块:支持编程和声明式事务管理实现特殊接口类。对应 spring-tx.jar,声明式事务使用
JMS模块:指Java消息服务,包含的功能为生产和消息的信息
五:WEB模块
Web模块:提供了基本的web开发集成特性。如:使用的Servlet监听器的IOC容器初始化及web应用上下文
Servlet模块:包括Spring模型-视图-控制器(MVC)实现Web应用程序
Struts模块:包含支持类内的Spring应用程序,集成了经典的Struts Web层
Portlet模块:提供了在portlet环境中使用MVC实现,类似Web-Servlet模块的功能
Web模块:提供了需要 spring 完成 web 相关功能时的功能. 如:由 tomcat 加载 spring 配置文件时需要有 spring-web 包
.Spring 框架中重要概念
容器(Container): Spring 当作一个大容器.
在老版本中是BeanFactory 接口.在新版本中是ApplicationContext 接口,是 BeanFactory 子接 口.BeanFactory 的功能在 ApplicationContext 中都有. 7.
从 Spring3 开始把 Spring 框架的功能拆分成多个 jar. Spring2 及以前就一个 jar
基本的Spring需要导入的jar包
也就是Core模块的相关jar包
另外需要导入Commons-loggging的jar包,是一个第三方的依赖包,主要用于处理日志
在src下建立applicationContext.xml(文件名称和路径可以自定义)
Spring的全局容器ApplicationContext。而applicationContext.xml 配置的信息最终存储到了 AppliationContext 容器中
<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">
beans>
建立一个实体类
package cn.com.pojo;
public class People {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
System.out.println("setId");
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("setName");
this.name = name;
}
@Override
public String toString() {
return "People{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
在Spring的配置文件中,配置实体类
<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="peo" class="cn.com.pojo.People">
bean>
beans>
public class Text {
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
People people=context.getBean("peo", People.class);
System.out.println(people);
}
}
这样的好处,创建对象不用new而是交给Spring,通过
创建对象. Spring将创建好的对象放入容器类,而我们只需要从容器中去拿。这就是IOC(控制反转)
默认配置文件被加载时创建对象
IOC(Inversion of Control) 控制反转
IoC 完成的事情原先由程序员主动通过 new 实例化对象事情,
转交给 Spring 负责.
控制反转中控制指的是:控制类的对象
控制反转中反转指的是转交给 Spring 负责.
Spring提供了两种IOC容器,分别是BeanFactory和ApplicationContext
在老版本中是BeanFactory 接口.在新版本中是ApplicationContext 接口
1.BeanFactory
BeanFactory是基础类型的IOC容器,由org.springframework.beans.factory.BeanFactory接口定义
BeanFactory提供了完整的IOC服务支持。BeanFactory就是一个管理Bean的工厂,它主要负责初始化各种Bean,并调用它们的生命周期方法
创建BeanFactory 实例时,需要提供Spring所管理容器的详细配置信息,这些信息通常采用XML文件形式来管理
BeanFactory factory=new XmlBeanFactory(new FileSystemResource("D:\\applicationContext.xml"));
2.ApplicationContext
ApplicationContext 是BeanFactory的子接口,也称为应用上下文接口。全路径为org.springframework.context.ApplicationContext
ApplicationContext不仅提供BeanFactory所有的功能,还以一种面向框架的方式增强BeanFactory的功能。
ApplicationContext接口的实例创建有两种方法
1.ClassPathXmlApplicationContext:从类路径的XML文件载入上下文定义信息,把上下文定义文件当作类路径资源
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
2.FileSystemXml:从文件系统中指定路径的XML文件载入上下文定义信息
ApplicationContext context= new FileSystemXmlApplicationContext("D:\\Spring\src\applicationContext.xml")
在老版本中是BeanFactory 接口.在新版本中是ApplicationContext 接口,
BeanFactory接口和ApplicationContext接口都是通过XML配置文件加载Bean的,相比之下,ApplicationContext提供更多的扩展功能
二者的主要区别是
BeanFactory采用的是延迟加载方案,只有在调用getBean()时才会实例化Bean.如果Bean的某一个属性没有注入,使用BeanFactory加载后,在第一次调用getBean()时会抛出异常。
而ApplicationContext则在初始化时就一次性创建所有bean,这样有利于所依赖的属性是否注入。
可以看出BeanFactory采用的是延迟加载方案,只有在调用getBean()时才会实例化Bean
ApplicationContext则在初始化时就一次性创建所有bean
无参构造创建:默认情况.
<bean id="peo" class="cn.com.pojo.People">
bean>
有参构造创建:需要配置
public People(int id, String name) {
this.id = id;
this.name = name;
}
建立有参构造方法
<bean id="peo" class="cn.com.pojo.People">
<constructor-arg name="id" value="1"/>
<constructor-arg name="name" value="张三"/>
bean>
使用有参构造方法需要添加
标签
标签的 name属性是构造方法的参数名 value属性设立值
除了name属性和value属性还有
index属性 :参数的索引从0开始
type属性:声明参数的类型 (需要区分关键字和封装类 如:int和Integer是不同的)
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
// BeanFactory factory=new XmlBeanFactory(new FileSystemResource("D:\\applicationContext.xml"));
System.out.println("------------获取bean----------------");
People people=context.getBean("peo", People.class);
System.out.println(people);
}
}
工厂设计模式:帮助创建类对象.一个工厂可以生产多个对象
实例工厂:需要先创建工厂,才能生产对象
package cn.com.factory;
import cn.com.pojo.People;
public class PeopleFactory {
public People newInstance(){
return new People(11,"kryie");
}
}
<bean id="factory" class="cn.com.factory.PeopleFactory">bean>
<bean id="peo" factory-bean="factory" factory-method="newInstance">
bean>
factory-bean指向factory的bean标签的id
factory-method指向factory中实例化对象的方法名
静态工厂:不需要创建工厂,快速创建对象
public class PeopleFactory {
public static People newInstance(){
return new People(11,"kryie");
}
}
<bean id="peo" class="cn.com.factory.PeopleFactory" factory-method="newInstance">bean>
通过class属性指定其对应的工厂实现类
可以通过构造方法设置值.
属性为基本数据类型
<bean id="peo" class="cn.com.pojo.People">
<property name="id" value="11"/>
<property name="name" value="kryie"/>
bean>
当属性是list类型时
<property name="list">
<list>
<value>1value>
<value>2value>
<value>3value>
list>
property>
当属性是数组时
<property name="strs" >
<array>
<value>1value>
<value>2value>
<value>3value>
array>
property>
当属性是set时
<property name="sets">
<set>
<value>1value>
<value>2value>
<value>3value>
set>
property>
当属性是map时
<property name="map">
<map>
<entry key="a" value="b" > entry>
<entry key="c" value="d" > entry>
map>
property>
当属性是Properties 类型时
<property name="demo">
<props>
<prop key="key">valueprop>
<prop key="key1">value1prop>
props>
property>
当属性为对象
当一个类(A)中需要依赖另一个类()对象时,把 B 赋值给 A 的过 程就叫做依赖注入
package cn.com.pojo;
public class School {
private String name;
private String address;
//省略get和set方法
@Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}
public class People {
private int id;
private String name;
private School school; //包含了一个对象
//此处省略get和set方法
@Override
public String toString() {
return "People{" +
"id=" + id +
", name='" + name + '\'' +
", school=" + school +
'}';
}
}
<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="cn.com.pojo.School">
<property name="name" value="sust"/>
<property name="address" value="xian"/>
bean>
<bean id="peo" class="cn.com.pojo.People">
<property name="id" value="11"/>
<property name="name" value="kryie"/>
<property name="school" ref="school"/>
bean>
beans>
当属性是对象时,使用ref属性指向其需要实例化bean的id
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("------------获取bean----------------");
People people=factory.getBean("peo", People.class);
System.out.println(people);
System.out.println(people.getSchool().getName());
}
}