01-Spring、概述、IOC解耦、依赖注入
一、Spring概述
1.1、概述
1.1.1、spring
Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control： 反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。
1.1.2 Spring 的发展历程
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 雏形）
2017 年 9 月份发布了 spring 的最新版本 spring 5.0 通用版（GA）
1.1.3、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 技术的最佳实践的范例。
1.1.4、spring的体系结构
二、IOC的概念和作用
2.1、程序的耦合和解耦
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，此处讨论软件工程中的耦合。 在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。
划分模块的一个准则就是高内聚低耦合。
它有如下分类：
1）内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另 一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
2）公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大 量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
3）外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传 递该全局变量的信息，则称之为外部耦合。
4）控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进 行适当的动作，这种耦合被称为控制耦合。
5）标记耦合 。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间 存在一个标记耦合。
6）数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形 式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另
一些模块的输入数据。
7） 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的
总结：
耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。
内聚与耦合：
内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之 间的相互依存度却要不那么紧密。
内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。
程序的耦合：
耦合：程序间的依赖关系
包括：
类之间的依赖
方法间的依赖
解耦：
降低程序间的依赖关系
实际开发中：
应该做到：编译期不依赖，运行时才依赖。
解耦的思路：
第一步：使用反射来创建对象，而避免使用new关键字。
第二步：通过读取配置文件来获取要创建的对象全限定类名。
JDBC程序解耦：
public class BeanFactory { private static Properties props; //定义一个Map来存储 我们要创建的对象，称之为容器。 private static Map<String,Object> beans; static { try { props = new Properties(); InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties"); props.load(in); beans = new HashMap<String, Object>(); //取出配置文件中的所有的key Enumeration<Object> keys = props.keys(); //遍历枚举 while(keys.hasMoreElements()){ String key = keys.nextElement().toString(); String beanPath = props.getProperty(key); //通过反射创建对象 Object value = Class.forName(beanPath).newInstance(); //将key和value存进容器中 beans.put(key, value); } } catch (Exception e) { e.printStackTrace(); } } //根据bean的全限定名称获取对象 public static Object getBean(String beanName){ return beans.get(beanName); } }
public class AccountServiceImpl implements AccountService{ // private AccountDao accountDao = new AccountDaoImpl(); private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao"); public void saveAccount() { int i=1 ; accountDao.saveAccount(); System.out.println(i); i++; } }
accountService=com.payn.service.impl.AccountServiceImpl
accountDao=com.payn.dao.impl.AccountDaoImpl
2.1.4、控制反转--Inversion Of Control
工厂：
就是负责获取容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。
原来：在获取对象的时候，都是采用new的方式，是主动的。
现在：在获取对象时，跟工厂要。由工厂为我们查找或创建对象。是被动的。
这种被动接受的方式获取对象的思想就是控制反转。是spring框架的核心之一。
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
明确 ioc 的作用：
削减计算机程序的耦合（解除代码中的依赖关系）。
三、使用spring的IOC解决程序耦合
注意：
spring5 版本是用 jdk8 编写的，所以要求我们的 jdk版本是 8及以上。
同时 tomcat 的版本要求 8.5及以上。
3.2、基于XML的配置
3.2.1、创建项目环境
3.2.2、在类的根路径下创建一个任意名称的xml文件(不能是中文)
-->如：bean.xml 类的根路径下-->因此，要放在maven项目中 src/main/resource文件夹下
3.2.3、让spring管理资源，在配置文件中配置service和dao
3.3、Spring基于XML的IOC细节
3.3.1、spring中工厂的类结构图
3.3.1.1、BeanFactory和ApplicationContext的区别
BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
BeanFactory 和 ApplicationContext 的区别：
创建对象的时间点不一样。
ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
BeanFactory：什么使用什么时候创建对象。
核心容器的两个接口引发出的问题：
ApplicationContext：单例对象适用采用此接口
它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
BeanFactory：多例对象使用
它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。
立即加载：
延迟加载：
3.3.1.2、ApplicationContext接口的实现类
ClassPathXmlApplicationContext：
它是从类的根路径下加载配置文件，推荐使用这种。
FileSystemXmlApplicationContext：
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。 (必须有访问权限)。
AnnotationConfigApplicationContext:
当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
3.3.2、IOC中 bean 标签和管理对象细节
3.3.2.1、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：指定类中销毁方法名称。
3.3.2.2、bean的作用范围和生命周期
单例对象：scope="singleton"
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象：scope="prototype"
每次访问对象时，都会重新创建对象实例。
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。|
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" scope="prototype" init-method="init" destroy-method="destroy"></bean>
/** * 模拟一个表现层，用于调用业务层 */ public class Client { /** * * @param args */ public static void main(String[] args) { //1.获取核心容器对象 // ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据id获取Bean对象 IAccountService as = (IAccountService)ac.getBean("accountService"); as.saveAccount(); //手动关闭容器 ac.close(); } }
单例对象：
多例对象：死亡是由垃圾回收机制实现
3.3.2.3、实例化Bean的三种方式
第一种方式：使用默认无参构造函数
<!--在默认情况下： 在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。 它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。 --> <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"/>
第二种方式：spring管理静态工厂--使用静态工厂的方法创建对象
/** * 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数） */ 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>
第三种方式：spring管理实例工厂--使用实例工厂的方法创建对象
/** * 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数） */ public class InstanceFactory { public AccountService getAccountService(){ return new AccountServiceImpl(); } }
配置实例工厂：
<!-- 此种方式是： 先把工厂的创建交给 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>
3.3.3、spring的依赖注入
3.3.3.1、依赖注入的概念
依赖注入：Dependency Injection。是 spring 框架核心 ioc 的具体实现。
我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。 ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。
这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。
3.3.3.2、构造函数注入--经常改变的数据不适用
就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。
public class AccountServiceImpl1 implements AccountService { // private AccountDao accountDao; public void saveAccount() { System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday); } private String name; private Integer age; private Date birthday; public AccountServiceImpl1(String name, Integer age, Date birthday) { this.name = name; this.age = age; this.birthday = birthday; } }
使用构造函数的方式，给 service 中的属性传值
要求：
类中需要提供一个对应参数列表的构造函数。
constructor-arg
属性：
index:指定参数在构造函数参数列表的索引位置 。索引位置从0开始。
type:指定参数在构造函数中的数据类型 。该数据类型也是构造函数中某个或某些参数的类型。-->无法确定唯一的。
name:指定参数在构造函数中的名称（即属性的名称。） 用这个找给谁赋值
=======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
value：它能赋的值是基本数据类型和 String 类型
ref：它能赋的值是其他 bean 类型，即必须得是在配置文件中配置过的 bean 。
优势：
在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。-->因为没有提供无参构造方法。
弊端：
改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。--->一般不使用这种方法。
<bean id="accountService1" class="com.itheima.service.impl.AccountServiceImpl1"> <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>
3.3.3.3、set方法注入
就是在类中提供需要注入成员的 set 方法。
set方法注入--->更常用的方式
property
标签的属性
name：用于指定注入时所调用的set方法名称
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
优势：
创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：
如果有某个成员必须有值，则获取对象是有可能set方法没有执行。
public class AccountServiceImpl2 implements AccountService { private String name; private Integer age; private Date birthday; /* public AccountServiceImpl2(String name, Integer age, Date birthday) { this.name = name; this.age = age; this.birthday = birthday; }*/ 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 Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; } public void saveAccount() { System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday); } }
<bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2"> <property name="name" value="Test"></property > <property name="age" value="21"></property> <property name="birthday" ref="now"></property> </bean>
3.3.3.4、使用p名称空间注入数据(本质还是调用set方法)
此种方式是通过在 xml中导入 p名称空间。
p:propertyName
注入数据，它的本质仍然是调用类中的 set 方法实现注入功能。
<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>
3.3.3.5、注入集合属性
就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。
此处介绍注入数组，List,Set,Map,Properties。
复杂类型的注入/集合类型的注入
用于给List结构集合注入的标签：
list array set
用于个Map结构集合注入的标签:
map props
结构相同，标签可以互换。
property的子标签：
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 String[] getMyStrs() { return myStrs; } public void setMyStrs(String[] myStrs) { this.myStrs = myStrs; } public List<String> getMyList() { return myList; } public void setMyList(List<String> myList) { this.myList = myList; } public Set<String> getMySet() { return mySet; } public void setMySet(Set<String> mySet) { this.mySet = mySet; } public Map<String, String> getMyMap() { return myMap; } public void setMyMap(Map<String, String> myMap) { this.myMap = myMap; } public Properties getMyProps() { return myProps; } 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); } }
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl3"> <property name="myStrs"> <!--给数组注入数据--> <set> <value>AAA</value> <value>BBB</value> <value>CCC</value> </set> </property> <property name="myList"> <array> <value>AAA</value> <value>BBB</value> <value>CCC</value> </array> </property> <property name="mySet"> <list> <value>AAA</value> <value>BBB</value> <value>CCC</value> </list> </property> <!--注入Map数据--> <property name="myMap"> <props> <prop key="textA">aaa</prop> <prop key="textB">bbb</prop> </props> </property> <property name="myProps"> <map> <entry key="testA" value="aaa"></entry> <entry key="testB"> <value>bbb</value> </entry> </map> </property> </bean> </beans>
浙公网安备 33010602011771号