怎样的架构的程序，我们认为是一个优秀的架构？
我们考虑的标准：可维护性好，可扩展性好，性能。
什么叫可扩展性好？
答：就是可以做到，不断的增加代码，但是可以不修改原来的代码的程序。
如何让程序的可维护性好，可扩展性好呢？
业界有一个公认的标准，高内聚，低耦合。
高内聚：就是尽量将代码写在与之功能描述一致的模块中。如User表的操作写在UserDAO里面就不用写在非UserDAO的类里面。
低耦合：就是尽量减少类与类之间的直接关系。（重点）
Spring框架就是通过IoC（控制反转）实现程序的解耦。从而提高程序的维护性和扩展性。
Spring概述
Spring是什么
Spring是一个JavaEE轻量级的一站式开发框架。
JavaEE： 就是用于开发B/S的程序。（企业级）
轻量级：使用最少代码启动框架，然后根据你的需求选择，选择你喜欢的模块使用。
重量级：早期有的EJB，开发一个HelloWorld程序都需要引入EBJ的全部模块
一站式：提供了，表示层（Struts2/SpringMVC），服务层，持久层的所有支持。
Spring框架出现的背景
在世界第一套有Java官方Sun公司推出的企业级开发框架EJB出现后，瞬间风靡全球。被各大公司所应用。
Spring之父，Rod Jonhson是一个音乐博士，在Sun公司的大力推广下，也成为EJB框架的使用者。
在深入研究完EJB框架（由Sun主导开发的一个JavaEE开发框架），无法接收这么一个框架被吹成世界第一，具体查看他吐槽EJB的书《Expert one on one J2EE design and development》
其中突出被他吐槽最厉害的一个点就EJB的重量级，就是只要使用EJB里面任何一个组件。都要将所有EJB的jar导进去。
于是他就提供了一个他的解决方案：轻量级的一站式企业开发框架。
那么什么是轻量级呢？
就是除内核模块（4个jar），其他模块由开发者自由选择使用，同时支持整合其他框架。
也可以称为就是可插拔式开发框架，像插头和插座一样，插上就用。这就是Spring框架核心理念。（Ioc）
那么什么是一站式呢？
就是Spring框架提供涵盖了JavaEE开发的表示层，服务层，持久层的所有组件功能。也就是说，原则上，学完一套Spring框架，不用其他框架就可以完成网站一条流程的开发。
如图：
Spring框架的作用
根据以上章节的描述。Spring是一个JavaEE一站式的开发框架。它提供的功能涵盖了JavaEE程序中的表示层，服务层，持久层功能组件。这意味着，使用了Spring框架，一个框架就可以满足整个JavaEE程序的开发。
但Spring框架，更加强调的是它的轻量级（模块的可插拔）！！也就是说，除了内核以外模块，如果你不想使用可以不用，它能够整合任何第三方的框架。
所以，在现实开发中，Spring主要用于整合其他框架。
总结
- Spring是一个一站式的企业级（JavaEE）开发框架，意味着，仅仅使用一个Spring框架就可以满足JavaEE开发的表示层，服务层，持久层的开发。
- Spring强调的理念是，轻量级。意味着Spring提供的功能模块，除了内核模块以外，开发人员可以选择性使用。
- 所以，Spring框架在现实开发中，主要的功能用于整合，各种开发来开发项目。
Spring框架包
Spring官方网站
https://spring.io/
框架包的下载
Spring官方提供的Maven方式的项目下载。
但是基于简单入门的原则，我们要通过导入包的方式来学习。需要下载框架的zip包
路径为：http://repo.springsource.org/libs-release-local/org/springframework/spring/
目录说明
包说明
包名 | 说明 |
spring-aop-4.3.2.RELEASE.jar | 实现了AOP的支持 |
spring-aspects-4.3.2.RELEASE.jar | AOP框架aspects支持包 |
spring-beans-4.3.2.RELEASE.jar | 内核支撑包，实现了处理基于xml对象存取 |
spring-context-4.3.2.RELEASE.jar | 内核支撑包，实现了Spring对象容器 |
spring-context-support-4.3.2.RELEASE.jar | 容器操作扩展包，扩展了一些常用的容器对象的设置功能 |
spring-core-4.3.2.RELEASE.jar | 内核支撑包，Spring的内核 |
spring-expression-4.3.2.RELEASE.jar | 内核支撑包，实现了xml对Spring表达式的支持 |
spring-instrument-4.3.2.RELEASE.jar | 提供了一些类加载的的工具类 |
spring-instrument-tomcat-4.3.2.RELEASE.jar | 提供了一些tomcat类加载的的工具类，实现对应Tomcat服务的调用 |
spring-jdbc-4.3.2.RELEASE.jar | SpringJDBC实现包，一个操作数据库持久层的子框架 |
spring-jms-4.3.2.RELEASE.jar | 集成jms的支持，jms：Java消息服务。 |
spring-messaging-4.3.2.RELEASE.jar | 集成messaging api和消息协议提供支持 |
spring-orm-4.3.2.RELEASE.jar | ORM框架集成包，实现了Hibernate，IBatis，JDO的集成。 |
spring-oxm-4.3.2.RELEASE.jar | Spring OXM对主流O/X Mapping框架做了一个统一的抽象和封装。就是对应XML读写框架的支持 |
spring-test-4.3.2.RELEASE.jar | Spring集成JUnit测试 |
spring-tx-4.3.2.RELEASE.jar | 事务代理的支持 |
spring-web-4.3.2.RELEASE.jar | SpringWeb通用模块 |
spring-webmvc-4.3.2.RELEASE.jar | SpringMVC子框架 |
spring-webmvc-portlet-4.3.2.RELEASE.jar | Spring对门户技术（portlet）的支持 |
spring-websocket-4.3.2.RELEASE.jar | Spring对websocket的支持 |
入门示例
Spring之所以可以实现模块的可插拔是支持依赖注入，所谓的依赖注入/控制反转就是不用new就可以创建对象。
需求：使用Spring框架不用new创建一个对象。
配置流程图
- 创建一个普通的类。
- 创建一个Spring配置文件，用于描述类与类之间的关系。
- 创建ApplicationContext容器对象根据Spring配置文件的描述，将对象创建并且放在Spring容器里面。
- 使用ApplicationContext容器对象的getBean方法，调用Spring容器里面的对象。
配置步骤说明
- 导入包
- 创建一个普通的类
- 创建一个Spring配置文件（去官方文档上拷贝约束）
- 编写一个测试类,使用ApplicationContext的子类对象根据配置文件创建容器。并且在容器里面获得创建的对象
配置步骤
第一步：搭建环境
1.创建一个Java项目
2.导入包，Spring的基础支撑包和依赖的日志包复制到lib文件下，并且加入项目中
---导入Spring基础支撑包
第二步：创建配置文件
- 在项目的src下面创建配置文件applicationContext.xml中并完成配置文件的约束,约束查找位置(spring框架/docs/spring-framework-reference/html/beans.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> |
第三步：创建对象到容器里面
- 创建一个类
package gao.com.zj.spring.service;
public class HwlloWrold {
private String name;
public void setName(String name) {
this.name = name;
}
public void say() {
System.out.println("你好，世界");
}
2.applicationContext.xml配置文件加入配置
<?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">
<!--
<bean id="" class=""></bean>
<bean>标签：spring管理java对象（类）的标签
id：被管理对象的唯一标识
class ：被管理类的全限定名
-->
<bean id="helloService" class="gao.com.zj.spring.service.HwlloWrold"></bean>
</beans>
3.测试使用getBean获得容器中的对象。
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import gao.com.zj.spring.service.*;
public class SpringTest {
@Test
public void testName() throws Exception {
// 创建HwlloWrold 对象 :强耦合 正控
//HwlloWrold service = new HwlloWrold();
//service.say();
// 使用Spring框架获取HwlloWrold对象
// IOC 控制反转（反控），将对象的创建权交给Spring
// 1. 读取配置文件，启动Spring框架，创建Spring容器对象
// ApplicationContext c = new ClassPathXmlApplicationContext("applicationContext.xml");
//ClassPathXmlApplicationContext:通过classpath路径直接获得加载的xml文件（推荐使用）
//FileSystemXmlApplicationContext：通过文件路径来获得加载的xml文件。
ClassPathXmlApplicationContext c = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.从Spring的容器对象中获取HwlloWrold对象
HwlloWrold bean = c.getBean("helloService",HwlloWrold.class);
bean.say();
}
}
Spring的IOC控制反转和依赖注入-重点-spring核心之一
IoC：Inverse of Control（控制反转）:
读作“反转控制”，更好理解，不是什么技术，而是一种设计思想，好比于MVC。就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。
正控：若调用者需要使用某个对象，其自身就得负责该对象的创建。
反控：调用者只管负责从Spring容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架。
（Don’t call me ,I’ll call you）
DI：Dependency Injection（依赖注入）
从字面上分析：
IoC：指将对象的创建权，反转给了Spring容器；
DI ：指Spring创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象。
IoC和DI其实是同一个概念的不同角度描述，DI相对IoC而言，明确描述了“被注入对象依赖IoC容器配置依赖对象”。
Container：容器，在生活中容器就是一种盛放东西的器皿，从程序设计角度看作是装对象的对象，因为存在对对象的存入、取出等操作，所以容器还要管理对象的生命周期。
1.1. IoC（控制反转）的概述
Spring号称是一个可以实现模块可插拔的JavaEE开发框架。那么它是如何实现程序的可插拔的呢？
实现程序可以插拔的核心理念就是，控制反转（Inversion of Control，英文缩写为IoC）
所谓的控制反转，就是将代码的调用权从调用方转移给被调用方（服务提供方）。
如图所示：
- 强耦合调用方式
将A调用B的对象修改为C类的对象，修改的是调用方的代码，所以我们认为代码的调用权在调用方。
- 基于IoC（控制反转）的调用方式
将上图的需求，修改为使用Ioc的调用代码方式。就是将代码的控制权从调用方修改为被调用方，意味着，代码的调用权转移给被调用方（我们也称为服务方），不用修改调用方的的代码
只要修改配置文件就实现对象的切换。
如下图：将A类调用B类的对象修改为C类的对象，修改的是被调用方的配置文件的代码，所以代码的调用权转移到了被调用方。通过控制反转，我们可以实现增加模块或者移除模块统一由配置文件关联，增加或者移除模块，配置XML配置文件即可。
我们将代码的调用权（控制权）从调用方转移给被调用方（服务提供方）的设计模式称为控制反转（IoC）
根据上图可以的得出，实现一个IoC的框架，必须要解决两个问题：
1.被调用方（服务方），在程序启动时就要创建好对象，放在一个容器里面。
2.调用方使用一个接口或类的引用（不用使用new），就可以创建获得对象。
我们将这种不用new，而是根据接口或者类的引用就可以从被调用的容器里获得创建的对象的方式称为依赖注入。
所以，控制反转（Ioc），就是依赖注入加上面向接口的编程思想的实现。
在这里，我们首先抓住一个重点：Spring之所以可以实现可插拔程序，是实现了不用new，使用类或接口就可以获得获得对象！
案列：
1.创建一个接口（HelloWorld），然后两个实现类（Hello1,Hello2）
2.在创建一个调用类（cliet）
3.使用spring来控制使用哪个实现类
4.测试
标签说明
alias标签
作用：为已配置的bean设置别名
|
bean标签的配置
标签作用
用于声明一个类,在启动Spring框架的时候根据该配置的类创建对象到容器里面
属性说明
<!-- <bean>标签：用于声明一个类,在启动Spring框架的时候根据该配置的类创建对象到容器里面 设置对象名（唯一标识符）,可以有多个名称,每个名称用逗号隔开 : name1,name2 ：设置对象名（唯一标识符，功能和name一样） 用于指定对象对应的类名 scope:用于设置的对象的作用范围，可选参数如下： 单例（默认） 对象出生：当程序加载配置文件创建容器时，创建 对象活着：只要容器还在，一直活着 对象死亡：应用停止，容器销毁，对象死亡 *prototype:多例（原型对象） 多例，每次使用都会创建一个 对象出生：当程序加载配置文件创建容器时，创建 对象活着：只要对象被使用，一直活着 Java垃圾回收机制回收 项目中，Spring将创建的对象放在request作用域中 项目中，Spring将创建的对象放在session作用域中 项目中，应用域portlet环境，如果没有protlet环境相当于session init-method:设置创建对象的时候，调用初始化方法 设置对象被回收时，调用注销的方法
--> <bean name="customerServiceImpl" class="com.zj.spring.service.impl.CustomerServiceImpl"></bean>
|
1.1.3. Bean作用范围
<bean id="" class="" scope="作用域"/>
singleton
| Spring IoC容器中仅存在一个Bean实例 （默认的scope） |
prototype | 多例 ，每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时 ，相当于执行new XxxBean()： |
request | 用于web开发，将Bean放入request范围 ，request.setAttribute("xxx") ， 在同一个request 获得同一个Bean
|
session | 用于web开发，将Bean 放入Session范围，在同一个Session 获得同一个Bean |
在开发中主要使用 scope="singleton"、 scope="prototype"
对于MVC中的Action/Controller使用prototype类型，其他使用singleton
|
<!-- <bean id="" class="" scope="作用域"/> scope : 配置当前bena的范围大小
singleton: 单例 ，在Spring IoC容器中仅存在一个Bean实例 （默认的scope） prototype: 多例 ，每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时 ，相当于执行new XxxBean() -->
<bean id="someBean" class="cn.zj.spring.pojo.SomeBean" scope="prototype"></bean> |
在Web开发的三层架构中
Web：一般都是多例
Service ：单例
DAO ：单例
实例化Bean的四种方式
构造器实例化（无参数构造器），最标准，使用最多
2.通过静态方法工厂创建（了解）
初始化和销毁方法
比如DataSource,SessionFactory最终都需要关闭资源:在Bean销毁之前,都要调用close方法.
<bean id="someBean" class="......"
该类中初始化方法名" destroy-method="该类中销毁方法名">
</bean>
init-method：bean生命周期初始化方法,对象创建后就进行调用
destroy-method:容器被销毁的时候，如果bean被容器管理，会调用该方法。
default-init-method
分析原理:
如果bean的scope="prototype",那么容器只负责创建和初始化，它并不会被spring容器管理。交给用户自己调用.
|
Spring依赖注入
DI：Dependency Injection（依赖注入）
从字面上分析：
IoC：指将对象的创建权，反转给了Spring容器；
DI ：指Spring创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象。
IoC和DI其实是同一个概念的不同角度描述，DI相对IoC而言，明确描述了“被注入对象依赖IoC容器配置依赖对象”。
所谓的依赖注入，就是属性不创建对象，通过配置文件的配置将Spring容器里面的对象注入给对应的属性
依赖注入有四种方式
setter注入，（属性注入）
1.setter注入,(也可以称之为属性注入) 使用setter注入： 1，使用bean元素的<property>子元素设置； 1，简单类型值，直接使用value赋值； 2，引用类型，使用ref赋值； 3，集合类型，直接使用对应的集合类型元素即可。 2，spring通过属性的setter方法注入值； 3 ，在配置文件中配置的值都是string，spring可以自动的完成类型的转换 |
构造器注入
使用哪种注入方式比较好（setter？构造器？）？
1，如果一个类必须依赖另一个类才能正常运行，用构造器；
2，但是构造器的参数如果过多，构造器很难看；
3，更多的还是使用setter注入；
4，可以使用@Required标签来要求一个属性必须注入
p命名空间注入
集合类型值注入
在处理的数据中，
有标量类型=基础数据类型以及包装类+String -- value属性
也有Spring容器里面的对象 --ref属性
还要很多数据JDK内置的数据结构：
- 键值对 Map 、Properties
- 数组
- 集合Set、List
package gao.com.zj.spring.client;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class cliet {
private String[] arr;
private List<String> list;
private Set<String> set;
private Map<String, Object> map;
private Properties prop;
public String[] getArr() {
return arr;
}
public void setArr(String[] arr) {
this.arr = arr;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public Set<String> getSet() {
return set;
}
public void setSet(Set<String> set) {
this.set = set;
}
public Map<String, Object> getMap() {
return map;
}
public void setMap(Map<String, Object> map) {
this.map = map;
}
public Properties getProp() {
return prop;
}
public void setProp(Properties prop) {
this.prop = prop;
}
@Override
public String toString() {
return "CollectionBean [arr=" + Arrays.toString(arr) + ", list=" + list + ", set=" + set + ", map=" + map
+ ", prop=" + prop + "]";
}
}
<?xml version="1.0" encoding="UTF-8"?>
<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="collectionBean" class="cn.zj.spring.pojo.CollectionBean">
<!-- arr 数组 -->
<property name="arr">
<array>
<value>java</value>
<value>c</value>
<value>c++</value>
</array>
</property>
<!-- list集合 -->
<property name="list">
<list>
<value>AA</value>
<value>BB</value>
<value>BB</value>
<value>CC</value>
</list>
</property>
<!-- set 集合 -->
<property name="set">
<set>
<value>AA</value>
<value>BB</value>
<value>BB</value>
<value>CC</value>
</set>
</property>
<!-- map -->
<property name="map">
<map>
<entry key="key1" value="value1"/>
<entry key="key2" value="value2"/>
<entry key="key3" value="value3"/>
</map>
</property>
<!-- Properties 特別注意 -->
<property name="prop">
<props>
<prop key="prop1">value1</prop>
<prop key="prop2">value2</prop>
<prop key="prop3">value3</prop>
</props>
</property>
</bean>
</beans>
1. 得properties文件的值
Spring配置文件支持通过xxx.properties文件的Key获得对应的值。实现该功能是通过
通过${Key}来获得Properties文件对应Key的值
使用Spring读取配置文件必须导入新的命名空间 context
导入命名空间方法
将命名空间和约束重新拷贝一份,将对于的全部替换成 context,然后关联context本地schema约束
|
jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=gzsxt
jdbc.maxActive=10
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
" >
<!-- 读取db.properties配置文件到Spring容器中 -->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 配置 阿里巴巴的 druid 数据源（连接池） -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<!--
SpringEL 语法 ${key}
-->
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT"/>
<!--
${username}如果key是username，name 默认spring框架调用的当前操作系统的账号
解决方案：可以统一给key加一个前缀
-->
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
<property name="maxActive" value="${jdbc.maxActive}"/>
</bean>
</beans>
package gao.com.zj.spring.test;
import javax.sql.DataSource;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
@Test
public void testName() throws Exception {
// 1. 读取配置文件，启动Spring框架，创建Spring容器对象
ApplicationContext c = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.从Spring的容器对象中获取clite对象
DataSource dataSource = c.getBean("dataSource", DataSource.class);
System.out.println(dataSource.getConnection());
System.out.println(dataSource);
}
}
小结
- 优秀的项目架构的特点
(1) 高内聚
① 项目分层开发（每次处理各自的任务，职责分明）
(2) 低耦合
① 对象与对象之间有不直接产生依赖（不直接new对象）
- 低耦合的解决方案
(1) 开发者自己底层使用反射进行封装相关代码
(2) 使用优秀的框架
- 什么是Spring？
(1) 轻量级一站式框架
(2) 轻量级
① Spring有20个模块，只需要四个模块即可启动Spring框架，其他模块按需引入即可
(3) 一站式
① Web开发的三层架构 ，Web层、Service层，Dao层 全部使用Spring框架完成
- Spring如何实现解耦
(1) IOC ：控制反转
① 将对象创建权交给Spring管理
② 负责对象生命周期（有效期）
③ 初始化方法，销毁方法
④ IOC创建对象实例有四种方式
1) 直接使用无参数构造函数-推荐
- <bean id = ‘’’ class =””>
2) 使用静态工厂创建bean
3) 使用实例工厂创建bean
4) 使用变种实例工厂，工厂类实现 FactoryBean接口
(2) DI ：依赖注入
① 将对象的属性通过Spring赋值
② Setter方法（属性）注入
③ 构造器注入
④ P命名空间注入
⑤ 支持值类型，引用类型和支持各种集合数据类型的注入
- Spring读取 .Properteis配置文件
- 综合案例-模拟注册功能-使用Spring管理对象
