Spring--一、Spring概述及Spring中基于XML的IOC配置

Spring–一、Spring概述及Spring中基于XML的IOC配置

视频:Spring5教程IDEA版-4天-2018黑马

教学资源 提取码:cwbz

Spring的概述(了解)

spring是什么

Spring是分层的Java SE/EE应用 full-stack轻量级开源框架,以IoC(Inverse Of Control:反转控制)和AOP(Aspect Oriented Programming:面向切面编程)为内核,提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术,还能整合开源世界众多著名的第三方框架和类库,逐渐成为使用最多的Java EE企业应用开源框架。

Spring的优势

方便解耦,简化开发

通过Spring提供的IoC容器,可以将对象间的依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。

AOP编程的支持

通过Spring的AOP功能,方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

声明式事务的支持

可以将我们从单调烦闷的事务管理代码中解脱出来,通过声明式方式灵活的进行事务的管理,提高开发效率和质量。

方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作,测试不再是昂贵的操作,而是随手可做的事情。

方便集成各种优秀框架

Spring可以降低各种框架的使用难度,提供了对各种优秀框架(Struts、Hibernate、Hessian、Quartz等)的直接支持。

降低JavaEE API的使用难度

Spring对JavaEE API(如JDBC、JavaMail、远程调用等)进行了薄薄的封装层,使这些API的使用难度大为降低。

Java源码是经典学习范例

Spring的源代码设计精妙、结构清晰、匠心独用,处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。

Spring的体系结构

1570021394756

Spring的两大核心为:AOP和IOC

AOP部分为:AOP、Aspects、Instrumentation、Messaging

IOC(核心容器)部分为Core Container部分

IOC的概念和作用

程序的耦合与解耦

程序的耦合即程序间的依赖关系:①类之间的依赖关系。②方法间的依赖关系。

解耦即降低程序间的依赖关系,实际开发中应做到编译期不依赖,运行时才依赖:

  1. 使用反射(Class.forName())来创建对象,避免使用new来创建对象。
  2. 通过读取配置文件来获取要创建的对象的全限定类名。
    1. 配置文件内容:唯一标识=全限定类名(key=value)

工厂模式解耦

在实际开发中我们可以把三层(参考JavaEE三层结构:Web(表现)层、业务层、DAO(数据)层)的对象都使用配置文件配置起来,当启动服务器应用加载的时候,让一个类中的方法通过读取配置文件,把这些对象创建出来并存起来。在接下来的使用的时候,直接拿过来用就好了。

那么,这个读取配置文件,创建和获取三层对象的类就是工厂。

建议了解单例多例对象来提高工厂模式解耦效率。

控制翻转-Inversion Of Control(IOC)

控制反转(IOC)即把创建对象的权利交给框架,是框架的重要特征,它包括依赖注入(Dependency Injection,简称DI)和依赖查找(Dependency Lookup)

原来我们创建对象是用new来主动创建的,即我们的项目对资源的使用是直接关联的,如图:1570085897052

现在,我们引入框架的工厂来帮我们创建生产对象,他负责给我们从指定容器中获取指定对象的类,这时候这个对象获取过来是不是我能用的,我们的应用本身已经无法得知了,工厂能得到哪个对象是根据配置文件中的全限定类名(key=value)获得的,我们的应用本身没有自主控制权。而原来的直接new的方法则应用本身是有自主控制权的。所以这种工厂模式降低了我们程序间的依赖关系,如图:1570086617087

即IOC用来削减计算机程序间的耦合。

使用Spring的IOC解决程序耦合

Spring的开发包

官网:http://spring.io/

Spring的目录结构:

  • dcos:API和开发规范
  • libs:jar包和源码
  • schema:约束

Spring基于XML的IOC细节

Spring中工厂的类结构图

1570088592204

TIM截图20191003153640

BeanFactory和ApplicationContext的区别

BeanFactory 才是Spring 容器中的顶层接口。ApplicationContext 是它的子接口。

BeanFactory 和ApplicationContext 的区别:创建对象的时间点不一样。

  • ApplicationContext:只要一读取配置文件,默认情况下就会创建对象。单例对象适用。常用此接口,Spring会根据对象的单例多例来选择。
  • BeanFactory:什么使用什么时候创建对象。多例对象适用。
ApplicationContext接口的实现类
  • ClassPathXmlApplicationContext:
    它是从类的根路径下加载配置文件 推荐使用这种
  • FileSystemXmlApplicationContext:
    它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置。
  • AnnotationConfigApplicationContext:
    当我们使用注解配置容器对象时,需要使用此类来创建spring 容器。它用来读取注解。

IOC中bean标签和管理对象细节

bean标签

作用:

  • 用于配置对象让spring来创建的。
  • 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

    属性:

  • id:给对象在容器中提供一个唯一标识。用于获取对象。

  • class:指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
  • scope:指定对象的作用范围。
    • singleton :默认值,单例的.
    • prototype :多例的.
    • request :WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中.
    • session :WEB项目中,Spring创建一个Bean的对象,将对象存入到session域中.
    • global session :WEB项目中,应用在Portlet环境.如果没有Portlet环境那么globalSession相当于session.
  • init-method:指定类中的初始化方法名称。
  • destroy-method:指定类中销毁方法名称。
bean的作用范围和生命周期

单例对象:scope=”singleton”

  • 一个应用只有一个对象的实例。它的作用范围就是整个引用。
  • 生命周期:
    • 对象出生:当应用加载,创建容器时,对象就被创建了。
    • 对象活着:只要容器在,对象一直活着。
    • 对象死亡:当应用卸载,销毁容器时,对象就被销毁了。

多例对象:scope=”prototype”

  • 每次访问对象时,都会重新创建对象实例。
  • 生命周期:
    • 对象出生:当使用对象时,创建新的对象实例。
    • 对象活着:只要对象在使用中,就一直活着。
    • 对象死亡:当对象长时间不用时,被java的垃圾回收器回收了。
实例化bean的三种方式

第一种方式:使用默认无参构造函数

1
2
3
<!--在默认情况下: 它会根据默认无参构造函数来创建类对象。如果bean中没有默认无参构造函数,将会创建失败。--> 
<bean id="accountService"
class="com.itheima.service.impl.AccountServiceImpl"/>

第二种方式:spring管理静态工厂-使用静态工厂的方法创建对象

1
2
3
4
5
6
/*模拟一个静态工厂,创建业务层实现类*/ 
public class StaticFactory {
public static IAccountService createAccountService(){
return new AccountServiceImpl();
}
}
1
2
3
4
5
6
7
8
9
<!-- 此种方式是:
使用StaticFactory类中的静态方法createAccountService创建对象,并存入spring容器
id属性:指定bean的id,用于从容器中获取
class属性:指定静态工厂的全限定类名
factory-method属性:指定生产对象的静态方法
-->
<bean id="accountService"
class="com.itheima.factory.StaticFactory"
factory-method="createAccountService"></bean>

第三种方式:spring管理实例工厂-使用实例工厂的方法创建对象

1
2
3
4
5
6
7
8
9
/**	
* 模拟一个实例工厂,创建业务层实现类
* 此工厂创建对象,必须现有工厂实例对象,再调用方法
**/
public class InstanceFactory {
public IAccountService createAccountService(){
return new AccountServiceImpl();
}
}
1
2
3
4
5
6
7
8
9
10
<!-- 此种方式是: 
先把工厂的创建交给spring来管理。 然后在使用工厂的bean来调用里面的方法
factory-bean属性:用于指定实例工厂bean的id。
factory-method属性:用于指定实例工厂中创建对象的方法。
-->
<bean id="instancFactory"
class="com.itheima.factory.InstanceFactory"></bean>
<bean id="accountService"
factory-bean="instancFactory"
factory-method="createAccountService"></bean>

Spring的依赖注入

依赖注入的概念

依赖注入是Spring框架核心IOC的具体实现

什么是依赖注入呢?即在当前类需要其他类的对象时,由Spring为我们提供,而不是自己创建,我们只需要在配置文件中说明依赖关系的维护。

依赖注入:

  • 能注入的数据有三类:
    • 基本类型和String
    • 其他bean类型(在配置文件或注解配置过的bean)
    • 复杂类型/集合类型
  • 注入的方式:
    • 使用构造函数提供
    • 使用set方法提供
    • 使用注解提供(下一篇)
构造函数的依赖注入

就是通过类的构造函数,给成员变量赋值。赋值操作是通过配置文件的方式,让Spring框架来帮我们注入。一般这种方式用于不经常更变的成员变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//这是我们需要调用的类
public class AccountServiceImpl implements IAccountService {
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);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<!-- 使用构造函数的方式,给service中的属性传值 
要求:
类中需要提供一个对应参数列表的构造函数。
涉及的标签: constructor-arg (bean标签内部)
属性:
index:指定参数在构造函数参数列表的索引位置
type:指定参数在构造函数中的数据类型
name:指定参数在构造函数中的名称 用这个找给谁赋值
=======上面三个都是找给谁赋值,下面两个指的是赋什么值的==============
value:它能赋的值是基本数据类型和String类型
ref:它能赋的值是其他bean类型,也就是说,必须得是在配置文件中配置过的bean
-->
<bean id="accountService"
class="com.itheima.service.impl.AccountServiceImpl">
<constructor-arg name="name" value="张三"></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>

Spring注入的类型默认为字符串,要注入其他bean类型时,他不能强制转换成该类型,需要另外在配置文件中创建一个bean类型,让该类型的构造函数帮我们创建好,再将该类型通过配置文件传入要注入的对象。

优势:在获取bean对象时,注入数据是必须的操作,否则对象无法创建成功。

弊端:改变了bean对象的实例化方式,使我们在创建对象时,如果用不到这些数据,也必须提供。

set方法注入

就是利用类中提供set方法类设置成员变量的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class AccountServiceImpl implements IAccountService { 
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(name+","+age+","+birthday);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- 通过配置文件给bean中的属性传值:使用set方法的方式 
涉及的标签: property(bean标签里面)
属性:
name:找的是类中set方法后面的部分
ref:给属性赋值是其他bean类型的
value:给属性赋值是基本数据类型和string类型的
实际开发中,此种方式用的较多。
-->
<bean id="accountService"
class="com.itheima.service.impl.AccountServiceImpl">
<property name="name" value="test"></property>
<property name="age" value="21"></property>
<property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

优势:创建对象时没有明确的限制,可以直接使用默认构造函数

弊端:如有某个成员必须有值,则获取对象可能set方法没有执行

复杂类型注入

本质上还是使用set方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class AccountServiceImpl implements IAccountService { 
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(mySet);
System.out.println(myMap);
System.out.println(myProps);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<!-- 注入集合数据 
List结构的: array,list,set
Map结构的 map,entry,props,prop
-->
<bean id="accountService"
class="com.itheima.service.impl.AccountServiceImpl">
<!-- 在注入集合数据时,只要结构相同,标签可以互换 -->
<!-- 给数组注入数据 -->
<property name="myStrs">
<set>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</set>
</property>
<!-- 注入list集合数据 -->
<property name="myList">
<array>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value> </array>
</property>
<!-- 注入set集合数据 -->
<property name="mySet">
<list>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</list>
</property>
<!-- 注入Map数据 -->
<property name="myMap">
<props>
<prop key="testA">aaa</prop>
<prop key="testB">bbb</prop>
</props>
</property>
<!-- 注入properties数据 -->
<property name="myProps">
<map>
<entry key="testA" value="aaa"></entry>
<entry key="testB">
<value>bbb</value>
</entry>
</map>
</property>
</bean>
使用P名称空间注入数据

通过再xml中导入p名称空间,使用p:propertyName来注入数据,本质还是调用set方法(视频里没讲,可能是少了一集)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class AccountServiceImpl4 implements IAccountService { 
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(name+","+age+","+birthday);
}
}
1
2
3
4
5
6
7
8
9
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:p="http://www.springframework.org/schema/p"
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="accountService"
class="com.itheima.service.impl.AccountServiceImpl4"
p:name="test" p:age="21" p:birthday-ref="now"/>
</beans>

接下来请看下一篇。。。

Donate comment here