1.1 Spring是什么
Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架,以 IoC(Inverse Of Control:反转控制)和 AOP(Aspect Oriented Programming:面向切面编程)为内核,提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术,还能整合开源世界众多著名的第三方框架和类库,逐渐成为使用最多的 Java EE 企业应用开源框架。
1.2 Spring的优势
方便解耦,简化开发
通过 Spring 提供的 IoC 容器,可以将对象间的依赖关系交由 Spring 进行控制,避免硬编码所造成的过度程序耦合。
用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。
AOP 编程的支持
通过 Spring 的 AOP 功能,方便进行面向切面的编程,许多不容易用传统 OOP(面向对象编程) 实现的功能可以通过AOP轻松应付。
** 声明式事务的支持**
可以通过声明式方式灵活的进行事务的管理,提高开发效率和质量。
方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作,测试不再是昂贵的操作,而是随手可做的事情。
等等
1.3 Spring的体系结构
二 、 IOC的概念和作用
程序耦合
耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系、数据传递关系。模块间联系越多,其耦合性越强,同时表明其独立性越差。
耦合是影响软件复杂程度和设计质量的一个重要因素,在设计上我们应采用以下原则:如果模块间必须存在耦合,就尽量使用数据耦合,少用控制耦合,限制公共耦合的范围,尽量避免使用内容耦合。
比如:
早期我们的 JDBC 操作,注册驱动时,我们为什么不使用 DriverManager 的 register 方法,而是采用 Class.forName 的方式?
Class.forName("com.mysql.jdbc.Driver");
原因就是:
我们的类依赖了数据库的具体驱动类(MySQL),如果这时候更换了数据库品牌(比如 Oracle),需要修改源码来重新数据库驱动。这显然不是我们想要的。
1.2 解决程序耦合的思路
反射注册驱动:
Class.forName(“com.mysql.jdbc.Driver”);//此处只是一个字符串
我们的类中不再依赖具体的驱动类,此时就算删除 mysql 的驱动 jar 包,依然可以编译,但是连接不了数据库。
同时,也产生了一个新的问题,mysql 驱动的全限定类名字符串是在 java 类中写死的,一旦要改还是要修改源码
解决这个问题也很简单,使用配置文件配置。
1.3 工厂模式解耦
在实际开发中我们可以把三层的对象都使用配置文件配置起来,当启动服务器应用加载的时候,让一个类中的方法通过读取配置文件,把这些对象创建出来并存起来。在接下来的使用的时候,直接拿过来用就好了。
那么,这个读取配置文件,创建和获取三层对象的类就是工厂。
1.4 控制反转 IOC
上面讲到的工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。
原来:我们在获取对象时,都是采用 new 的方式。是主动的
//例如
Person p=new Person();
现在:
我们获取对象时,同时跟工厂要,有工厂为我们查找或者创建对象。是被动的。
明确 ioc 的作用:
削减计算机程序的耦合(解除我们代码中的依赖关系)。
三 、 使用Spring 的 IOC
- 准备 spring 的开发包
- 创建业务层接口和实现类
public interface IAccountService 接口类
public class AccountService implements IAccountService 实现类
3.创建持久层接口和实现类
public interface IAccountDao
public class AccountDao implements IAccountDao
4.第一步:拷贝必备的 jar 包到工程的 lib 目录中
5.在类的根路径下创建一个任意名称的 xml 文件(不能是中文)
6.让 spring 管理资源,在配置文件中配置 service 和 dao
<!-- bean 标签:用于配置让 spring 创建对象,并且存入 ioc 容器之中
id 属性:对象的唯一标识。
class 属性:指定要创建对象的全限定类名
-->
<!-- 配置 service -->
<bean id="accountService" class="*.*.service.impl.AccountService">
</bean>
<!-- 配置 dao --> <bean id="accountDao" class="*.*.dao.impl.AccountDao"></bean>
Spring中工厂的类结构图
BeanFactory 和 ApplicationContext 的区别
BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
BeanFactory 和 ApplicationContext 的区别:
创建对象的时间点不一样。
ApplicationContext:只要一读取配置文件,默认情况下就会创建对象。
BeanFactory:什么使用什么时候创建对象
ApplicationContext 接口的实现类
ClassPathXmlApplicationContext:
它是从类的根路径下加载配置文件 推荐使用这种
FileSystemXmlApplicationContext:
它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext:
当我们使用注解配置容器对象时,需要使用此类来创建 spring 容器。它用来读取注解。
IOC中bean标签和管理对象细节
1.bean 标签:
用于配置对象让 spring 来创建的。
默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性:
- id:给对象在容器中提供一个唯一标识。用于获取对象。
- class:指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
- scope:指定对象的作用范围。
----singleton :默认值,单例的.
----prototype :多例的. - init-method:指定类中的初始化方法名称。
- destroy-method:指定类中销毁方法名称。
bean的作用范围和生命周期
- 单例对象:scope=“singleton”
对象出生:当应用加载,创建容器时,对象就被创建了。
对象活着:只要容器在,对象一直活着。
对象死亡:当应用卸载,销毁容器时,对象就被销毁了。 - 多例对象:scope=“prototype”
对象出生:当使用对象时,创建新的对象实例。
对象活着:只要对象在使用中,就一直活着。
对象死亡:当对象长时间不用时,被 java 的垃圾回收器回收了。
bean对象实例化
- 第一种方式:使用默认无参构造函数
<bean id="accountService" class="*.*.service.impl.AccountService"/>
- 第二种方式:spring 管理静态工厂-使用静态工厂的方法创建对象
public class StaticFactory {
public static IAccountService createAccountService(){
return new AccountService();
} }
<bean id="accountService"
class="*.*.factory.StaticFactory"
factory-method="createAccountService"></bean>
- 第三种方式:spring 管理实例工厂-使用实例工厂的方法创建对象
/**
* 模拟一个实例工厂,创建业务层实现类
* 此工厂创建对象,必须现有工厂实例对象,再调用方法
*/
public class InstanceFactory {
public IAccountService createAccountService(){
return new AccountService();
} }
<!-- 此种方式是:
先把工厂的创建交给 spring 来管理。
然后在使用工厂的 bean 来调用里面的方法
factory-bean 属性:用于指定实例工厂 bean 的 id。
factory-method 属性:用于指定实例工厂中创建对象的方法。
--> <bean id="instancFactory"
class=".factory.InstanceFactory"></bean>
<bean id="accountService"
factory-bean="instancFactory"
factory-method="createAccountService"></bean>
spring的依赖注入
Denpendency Injection:它是 spring 框架核心 ioc 的具体实现。
程序在编写时,通过控制反转,把对象的创建交给了 spring,但是代码中不可能出现没有依赖的情况。
ioc 解耦只是降低他们的依赖关系,但不会消除。
例如:我们的业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系,在使用 spring 之后,就让 spring 来维护了。
简单的说,就是坐等框架把持久层对象传入业务层,而不用我们自己去获取。
//比如yi个类中有成员变量 需要调用它的构造函数来注入
public class a implements b {
private String name;
private Integer age;
private Date birthday;
public AccountServiceImpl(String name, Integer age, Date birthday) {
this.name = name;
this.age = age;
this.birthday = birthday; }
}//这个时候就可以在xml中调用bean来注入
constructor-arg:构造函数注入值
属性:
index:指定参数在构造函数参数列表的索引位置
type:指定参数在构造函数中的数据类型
name:指定参数在构造函数中的名称
=======上面三个都是找给谁赋值,下面两个指的是赋什么值的==============
value:它能赋的值是基本数据类型和 String 类型
ref:它能赋的值是其他 bean 类型,也就是说,必须得是在配置文件中配置过的 bean
<bean id="a" class="a">
<constructor-arg name="name" value="jack"></constructor-arg> <constructor-arg name="age" value="18"></constructor-arg> <constructor-arg name="birthday" ref="now"></constructor-arg>
在bean中调用复杂类型时需要使用ref引用
</bean>
<bean id="now" class="java.util.Date"></bean>
set方法注入
可以在类中设置成员变量的set方法来注入
public class A implements B {
private String name;
private Date birthday;
public void setName(String name) {
this.name = name;
}
public void setBirthday(Date birthday) {
this.birthday = birthday; }
}
这是需要使用bean中的property标签
<bean id="A" class="A">
<property name="name" value="JACK"></property>
<property name="birthday" ref="now"></property></bean>
<bean id="now" class="java.util.Date"></bean>
使用p名称空间注入(其本质还是调用set方法)
此种方式是通过在 xml 中导入 p 名称空间,使用 p:propertyName 来注入数据,它的本质仍然是调用类中的set 方法实现注入功能。
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
//需要导入xmlns:p
>
<bean id="a"
class="a"
p:name="t" p:age="21" p:birthday-ref="now"/>
</beans>
<bean id="now" class="java.util.Date"></bean>
注入集合属性
注入类似 List ,Map集合的时候
<bean id="" class="l">
<!-- 在注入集合数据时,只要结构相同,标签可以互换 -->
<!-- 给数组注入数据 -->
<property name="myStrs">
<Arrays>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</Arrays>
</property>
<!-- 注入 list 集合数据 -->
<property name="myList">
<List>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</List>
</property>
<!-- 注入 set 集合数据 -->
<property name="mySet">
<Set>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</Set>
</property>
<!-- 注入 Property 数据 -->
<property name="myMap">
<props>
<prop key="testA">aaa</prop>
<prop key="testB">bbb</prop>
</props>
</property>
<property name="myProps">
<!-- 注入 Map 数据 -->
<map>
<entry key="testA" value="aaa"></entry>
<entry key="testB">
<value>bbb</value></entry>
</map>
</property>
</bean>