1.Spring概述
1.1什么是spring
Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control： 反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多 著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架
1.2spring的发展历程
1997 年 IBM提出了EJB 的思想
1998 年，SUN制定开发标准规范 EJB1.0
1999 年，EJB1.1 发布
2001 年，EJB2.0 发布
2003 年，EJB2.1 发布
2006 年，EJB3.0 发布
Rod Johnson（spring之父）
Expert One-to-One J2EE Design and Development(2002)
阐述了 J2EE 使用EJB 开发设计的优点及解决方案
Expert One-to-One J2EE Development without EJB(2004)
阐述了 J2EE 开发不使用 EJB的解决方式（Spring 雏形）
1.3spring的优势
- 方便解耦，简化开发 （高内聚低耦合）
spring就是一个大工厂(容器)可以将所有对象创建和依赖关系维护交给spring管理 - spring工厂是用于生成bean .AOP编程的支持
- Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持 - 只需要通过配置就可以完成对事务的管理，而无需手动编程,方便程序的测试
- Spring对Junit4支持，可以通过注解方便的测试Spring程序方便集成各种优秀框架
- Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持,降低JavaEE API的使用难度
- Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低
1.4spring体系结构
2.使用spring的IOC解决程序耦合问题
2.1什么是程序的耦合
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调 用模块的方式以及通过界面传送数据的多少。
模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系、数据传递关系.模块间联系越多,其耦合性越强,同时表明其独立性越差( 降低耦合性，可以提高其独立 性).耦合性存在于各个领域,而非软件设计中独有的,但是我们只讨论软件工程中的耦合。
在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个 准则就是高内聚低耦合
2.2IOC案例
2.2.1准备开发包
- 官网:http://spring.io/
- .创建maven工程
- .导入相关的spring包,在pom.xml中进行配置
- 系统自动导入相关的jar包
2.2.2创建目标类
1.提供AccountService接口和实现类
public interface AccountService {
void saveAccount();
}
public class AccountServiceImpl implements AccountService {
public AccountServiceImpl(){
System.out.println("对象被创建了");
}
public void saveAccount() {
System.out.println("service 中的saveAccount方法执行了");
}
}
2.2.3准备开发包
- 在类的根路径下创建一个任意名称的xml文件(不能是中文)
2.给配置文件导入约束
约束文件位置: /spring-framework-5.0.2.RELEASE/docs/spring-framework-reference/html5/core.html
<?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">
</beans>
3.让spring管理资源,在配置文件中配置service和dao
4.测试
3.Spring基于 XML 的 IOC 细节
3.1spring 中工厂的类结构图
BeanFactory才是spring容器的顶层接口, ApplicationContext是它的子接口
3.2两个工厂类
-
BeanFactory ：这是一个工厂，用于生成任意bean。
-
ApplicationContext：是BeanFactory的子接口，功能更强大。（国际化处理、事件传递、Bean自动装配、各种不同应用层的Context实现）
ApplicationContext的三个常用实现类
*ClassPathXmlApplicationContext:它可以加载类路径下的配置文件
要求配置文件必须在类路径下,不在的话,无法加载(更常用)
*FileSystemXmlApplicationContext:它可以加载磁盘任一路径下的配置文件,
要求配置文件必须有访问权限
*AnnotationConfigApplicationContext:它是用于读取注解创建容器
BeanFactory和 ApplicationContext 的区别
核心容器的两个接口的区别:
* ApplicationContext: 单例对象使用 ( 更多使用此接口)
* 它在创建核心容器时,创建对象采取的策略是采用立即加载的方式,
* 也就是说,只要一读取配置文件,马上就创建配置文件中的对象
*
* BeanFactory: 多例对象使用
* 它在创建核心容器时,创建对象使用的策略是采用延迟加载的方式
* 也就是说,什么时候根据id获取对象,什么时候才真正的创建对象
3.3IOC中bean标签的管理对象细节
3.3.1 bean标签
作用： 用于配置对象让 spring 来创建的。 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功
3.3.1.1 创建bean的三种方式
方式一:使用默认构造函数创建
在spring的配置文件中,使用bean标签,配以id和class属性之后,且没有其他属性和标签值
采用的就是默认构造函数创建bean对象,此时如果类中没有默认构造函数,则对象无法创建
如果没有,会报错: BeanInstantiationException /NoSuchMethodException:
<bean id="accountService" class="com.itcast.Service.Impl.AccountServiceImpl">
</bean>
方式二:使用普通工厂中的方法创建对象(使用某个类中的方法创建对象,并存入spring容器)
public class instanceFactory {
public AccountService getAccountService(){
return new AccountServiceImpl();
}
}
<!-- 此种方式是：
先把工厂的创建交给 spring 来管理。 然后在使用工厂的 bean 来调用里面的方法
factory-bean 属性：用于指定实例工厂 bean 的 id。
factory-method 属性：用于指定实例工厂中创建对象的方法。
-->
<bean id="instanceFactory"
class="com.itcast.factory.instanceFactory"></bean>
<bean id="accountService"
factory-bean="instanceFactory"
factory-method="getAccountService"></bean>
方式三:使用静态工厂中的静态方法(某个类中的静态方法创建对象,并存入spring容器)
//模拟一个静态工厂,创建业务层实现类
public class staticFactory {
public static AccountService getAccountService(){
return new AccountServiceImpl();
}
}
<!-- 此种方式是:
使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
id 属性：指定 bean 的 id，用于从容器中获取
class 属性：指定静态工厂的全限定类名
factory-method 属性：指定生产对象的静态方法
-->
<bean id="accountService"
class="com.itheima.factory.StaticFactory"
factory-method="createAccountService"></bean>
3.3.1.2bean标签的作用范围调整
bean的scope属性:
作用:用于指定bean的作用范围
singleton:单例的(默认值) 只创建一次对象
prototype:多例的
request :作用于web应用的请求范围
session:作用于web应用的会话范围
global-session:作用于集群环境的会话范围(全局会话范围),当不是集群环境时,相当于session
init-method :指定类中的初始化方法名称
destory-method :指定类中销毁方法名称
3.3.1.3bean标签的生命周期
*单例对象
出生:当容器创建时,对象出生
活着:只要容器还在,对象一直活着
死亡:容器销毁,对象死亡
总结:单例对象的生命周期和容器同步
*多例对象
出生:当我们使用对象时,spring框架为我们创建
活着:对象在使用过程中,就一直活着
死亡:当对象长时间不用且没有别的对象引用时,由java的垃圾回收器回收
4.spring的依赖注入
4.1 依赖注入的概念
依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。 我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。 ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。 那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。 简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。
4.2 注入的方式
1.可以注入的数据:三种
- 基本类型和String
- 其他bean类型(在配置文件中或者注解配置过的bean)
- 复杂类型/集合类型
2.注入的方式: 三种 .
- 使用构造函数提供
- 使用set方法提供
- 使用注解提供
方式一:构造函数注入
顾名思义，就是使用类中的构造函数，给成员变量赋值。
注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。
具体代码如下：
/*
模拟账户的业务层实现类
*/
public class AccountServiceImpl implements AccountService {
//如果是经常变化的数据并不适用于注入的方式
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;
}
public void saveAccount() {
System.out.println( name + "..." + age+"..."+ birthday);
}
}
/*
bean.xml中的配置
*/
<!--构造函数注入
*使用标签:constructor-arg
*标签出现的位置: bean标签内
*标签中的属性
type:用于指定要注入的数据的数据类型,该数据的类型也是构造函数中某个或某些参数的类型
index:用于指定要注入的数据给构造函数中指定索引位置的参数赋值,索引的位置时从0开始的
name:用于指定构造函数中指定名称的参数赋值 (常用)
***************以上三个用于指定给构造函数中哪个参数赋值*****************
value:用于提供基本类型和String类型的数据
ref:用于指定其他的bean类型数据,它指的是在spring的ioc核心容器中,出现过的bean对象
特点(优势):在获取bean对象时,注入数据时必须的操作,否则对象无法创建成功
缺点:改变了bean对象的实例化方式,使我们在创建对象时,如果用不到这些数据额也必须提供
-->
<bean id="accountService" class="com.itcast.Service.Impl.AccountServiceImpl" scope="prototype">
<constructor-arg name="name" value="text"></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
<constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<bean id="now" class="java.util.Date"></bean>
方式二:set方法注入 (更常用)
顾名思义，就是在类中提供需要注入成员的 set 方法。具体代码如下
/*
模拟账户的业务层实现类
*/
public class AccountServiceImpl2 implements AccountService {
private String name;
private Integer age;
private Date birthday;
public void setName(String name) {
this.name = name;
}
public void setAge(Integer age) {
this.age = age;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public void saveAccount() {
System.out.println("service 中的saveAccount方法执行了" + name + "..." + age+"..."+ birthday);
}
}
/*
bean.xml中的配置
*/
<!-- set方法注入
*涉及的标签 property
*出现的位置: bean标签内部
*标签的属性:
name:用于指定注入是所调用的set方法名称
value: 用于提供基本类型和String类型的数据
ref :用于指定其他bean类型数据,它指的是在spring的ioc核心容器中,出现过的bean对象
set方法的优势:创建对象时没有明确的限制,可以直接使用默认构造函数
弊端: 如果某个成员必须有值,则获取对象时,set方法没有执行,无法保证一定注入
-->
<bean id="accountService2" class="com.itcast.Service.Impl.AccountServiceImpl2">
<property name="name" value="text"></property>
<property name="age" value="21"></property>
<property name="birthday" ref = "now"></property>
</bean>
方式三:复杂类型的注入/集合类型的注入
顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式
只不过变量的数据类型都是集合。 我们这里介绍注入数组，List,Set,Map,Properties。
具体代码如下:
/*
模拟账户的业务层实现类
*/
public class AccountServiceImpl3 implements AccountService {
//演示第三种注入方式
private String[] myStrs;
private List<String> myList;
private Set<String> mySet;
private Map<String ,String> myMap ;
private Properties myProps;
public void setMyStrs(String[] myStrs) {
this.myStrs = myStrs;
}
public void setMyList(List<String> myList) {
this.myList = myList;
}
public void setMySet(Set<String> mySet) {
this.mySet = mySet;
}
public void setMyMap(Map<String, String> myMap) {
this.myMap = myMap;
}
public void setMyProps(Properties myProps) {
this.myProps = myProps;
}
public void saveAccount() {
System.out.println(Arrays.toString(myStrs));
System.out.println(myList);
System.out.println(myMap);
System.out.println(mySet);
System.out.println(myProps);
}
}
/*
bean.xml中的配置
*/
<!--复杂类型的注入/集合类型的注入
*用于给list结构集合注入的标签: list array set
*用于给map集合注入的标签: map props
<!-- 在注入集合数据时，只要结构相同，标签可以互换 -->
-->
<bean id="accountService3" class="com.itcast.Service.Impl.AccountServiceImpl3">
<property name="myStrs">
<array>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</array>
</property>
<property name="myList">
<list>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</list>
</property>
<property name="mySet">
<set>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</set>
</property>
<property name="myMap">
<map>
<entry key="testA" value="aaa"></entry>
<entry key="testB">
<value>bbb</value>
</entry>
</map>
</property>
<property name="myProps">
<props>
<prop key="c">ccc</prop>
<prop key="d">ddd</prop>
<prop key="e">eee</prop>
</props>
</property>
</bean>
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
