认识 Spring 框架
Spring 框架是 Java 应用最广的框架,它的成功来源于理念,而不是技术本身,它的理念包括 IoC (Inversion of Control,控制反转) 和 AOP(Aspect Oriented Programming,面向切面编程)。
什么是 Spring:
- Spring 是一个轻量级的 DI / IoC 和 AOP 容器的开源框架,来源于 Rod Johnson 在其著作 《Expert one on one J2EE design and development》 中阐述的部分理念和原型衍生而来。
- Spring 提倡以 “最少侵入” 的方式来管理应用中的代码,这意味着我们可以随时安装或者卸载 Spring
- 适用范围:任何 Java 应用
- Spring 的根本使命:简化 Java 开发
尽管 J2EE 能够赶上 Spring 的步伐,但 Spring 并没有停止前进, Spring 继续在其他领域发展,而 J2EE 则刚刚开始涉及这些领域,或者还没有完全开始在这些领域的创新。移动开发、社交 API 集成、NoSQL 数据库、云计算以及大数据都是 Spring 正在涉足和创新的领域。Spring 的前景依然会很美好。
Spring 中常用术语:
- 框架:是能完成一定功能的半成品。
框架能够帮助我们完成的是:项目的整体框架、一些基础功能、规定了类和对象如何创建,如何协作等,当我们开发一个项目时,框架帮助我们完成了一部分功能,我们自己再完成一部分,那这个项目就完成了。 - 非侵入式设计:
从框架的角度可以理解为:无需继承框架提供的任何类
这样我们在更换框架时,之前写过的代码几乎可以继续使用。 - 轻量级和重量级:
轻量级是相对于重量级而言的,轻量级一般就是非入侵性的、所依赖的东西非常少、资源占用非常少、部署简单等等,其实就是比较容易使用,而重量级正好相反。 - JavaBean:
即符合 JavaBean 规范的 Java 类 - POJO:即 Plain Old Java Objects,简单老式 Java 对象
它可以包含业务逻辑或持久化逻辑,但不担当任何特殊角色且不继承或不实现任何其它Java框架的类或接口。
注意:bean 的各种名称——虽然 Spring 用 bean 或者 JavaBean 来表示应用组件,但并不意味着 Spring 组件必须遵循 JavaBean 规范,一个 Spring 组件可以是任意形式的 POJO。
- 容器:
在日常生活中容器就是一种盛放东西的器具,从程序设计角度看就是装对象的的对象,因为存在放入、拿出等操作,所以容器还要管理对象的生命周期。
Spring 的优势
- 低侵入 / 低耦合 (降低组件之间的耦合度,实现软件各层之间的解耦)
- 声明式事务管理(基于切面和惯例)
- 方便集成其他框架(如MyBatis、Hibernate)
- 降低 Java 开发难度
- Spring 框架中包括了 J2EE 三层的每一层的解决方案(一站式)
Spring 能帮我们做什么
①.Spring 能帮我们根据配置文件创建及组装对象之间的依赖关系。
②.Spring 面向切面编程能帮助我们无耦合的实现日志记录,性能统计,安全控制。
③.Spring 能非常简单的帮我们管理数据库事务。
④.Spring 还提供了与第三方数据访问框架(如Hibernate、JPA)无缝集成,而且自己也提供了一套JDBC访问模板来方便数据库访问。
⑤.Spring 还提供与第三方Web(如Struts1/2、JSF)框架无缝集成,而且自己也提供了一套Spring MVC框架,来方便web层搭建。
⑥.Spring 能方便的与Java EE(如Java Mail、任务调度)整合,与更多技术整合(比如缓存框架)。
spring模块介绍:
- Data Access/Integration层包含有JDBC、ORM、OXM、JMS和Transaction模块。
- Web层包含了Web、Web-Servlet、WebSocket、Web-Porlet模块。
- AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现。
- Core Container(核心容器): 包含有Beans、Core、Context和SpEL模块。
- Test模块支持使用JUnit和TestNG对Spring组件进行测试。
Spring IoC 和 DI 简介
IoC:Inverse of Control(控制反转)
- 读作 “反转控制”,更好理解,不是什么技术,而是一种设计思想,就是将原本在程序中手动创建对象的控制权,交由Spring框架来管理。
- 正控:若要使用某个对象,需要自己去负责对象的创建
- 反控:若要使用某个对象,只需要从 Spring 容器中获取需要使用的对象,不关心对象的创建过程,也就是把创建对象的控制权反转给了Spring框架
- 好莱坞法则: Don’t call me ,I’ll call you
编写第一个 Spring 程序:
1.新建java项目:
2.新建lib目录,添加必要的架包jar:
3.在src目录下,创建类Source:
package pojo; /**新建Source类 * @author lenovo */ public class Source { private String fruit; // 类型 private String sugar; // 糖分描述 private String size; // 大小杯 /* setter and getter */ public String getFruit() { return fruit; } public void setFruit(String fruit) { this.fruit = fruit; } public String getSugar() { return sugar; } public void setSugar(String sugar) { this.sugar = sugar; } public String getSize() { return size; } public void setSize(String size) { this.size = size; } }
4.创建beans.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 name="source" class="pojo.Source"> <property name="fruit" value="橙子"/> <property name="sugar" value="多糖"/> <property name="size" value="超大杯"/> </bean> </beans>
5.创建SpringTest测试类:
package test; import org.junit.Test; import pojo.Source; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * @author lenovo */ public class SpringTest { @Test public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext( new String[]{"beans.xml"} ); Source source = (Source) context.getBean("source"); System.out.println(source.getFruit()); System.out.println(source.getSugar()); System.out.println(source.getSize()); } }
运行结果:
橙子
多糖
超大杯
进程已结束,退出代码 0
- 总结:
- 传统的方式:
通过new 关键字主动创建一个对象。 dog d=new dog(); - IOC方式:
对象的生命周期由Spring来管理,直接从Spring那里去获取一个对象。 IOC是反转控制 (Inversion Of Control)的缩写,就像控制权从本来在自己手里,交给了Spring。dog d=spring生产
DI:Dependency Injection(依赖注入)
- 指 Spring 创建对象的过程中,将对象依赖属性(简单值,集合,对象)通过配置设值给该对象
1.在src目录下,创建类JuiceMaker:
package pojo; /** * @author lenovo */ public class JuiceMaker { /** * 唯一关联了一个 Source 对象 */ private Source source = null; /* setter and getter */ public Source getSource() { return source; } public void setSource(Source source) { this.source = source; } public String makeJuice(){ String juice = "xxx用户点了一杯" + source.getFruit() + source.getSugar() + source.getSize(); return juice; } }
2.在 xml 文件中配置 JuiceMaker 对象:
<?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 name="source" class="pojo.Source"> <property name="fruit" value="橙子"/> <property name="sugar" value="多糖"/> <property name="size" value="超大杯"/> </bean> <bean name="juickMaker" class="pojo.JuiceMaker"> <!-- 注意:这里要使用 ref 来注入另一个对象--> <property name="source" ref="source" /> </bean> </beans>
3. SpringTest 中添加如下代码:
package test; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import pojo.JuiceMaker; import pojo.Source; /** * @author lenovo */ public class SpringTest { @Test public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext( new String[]{"beans.xml"} ); Source source = (Source) context.getBean("source"); System.out.println(source.getFruit()); System.out.println(source.getSugar()); System.out.println(source.getSize()); JuiceMaker juiceMaker = (JuiceMaker) context.getBean("juickMaker"); System.out.println(juiceMaker.makeJuice()); } }
4.运行测试类:
结果:
橙子
多糖
超大杯
xxx用户点了一杯橙子多糖超大杯
总结: IoC 和 DI 其实是同一个概念的不同角度描述,DI 相对 IoC 而言,明确描述了“被注入对象依赖 IoC 容器配置依赖对象”
oC 如何实现的
最后我们简单说说IoC是如何实现的。想象一下如果我们自己来实现这个依赖注入的功能,:
- 读取标注或者配置文件,看看JuiceMaker依赖的是哪个Source,拿到类名
- 使用反射的API,基于类名实例化对应的对象实例
- 将对象实例,通过构造函数或者 setter,传递给 JuiceMaker
spring的IoC原理:https://www.tianmaying.com/tutorial/spring-ioc
Spring AOP 简介
如果说 IoC 是 Spring 的核心,那么面向切面编程就是 Spring 最为重要的功能之一了,在数据库事务中切面编程被广泛使用。
AOP 即 Aspect Oriented Program 面向切面编程
首先,在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能。
- 所谓的核心业务,比如登陆,增加数据,删除数据都叫核心业务
- 所谓的周边功能,比如性能统计,日志,事务管理等等
周边功能在 Spring 的面向切面编程AOP思想里,即被定义为切面
在面向切面编程AOP的思想里面,核心业务功能和切面功能分别独立进行开发,然后把切面功能和核心业务功能 "编织" 在一起,这就叫AOP
AOP 的目的
AOP能够将那些与业务无关,却为业务模块所共同调用的逻辑或责任(例如事务处理、日志管理、权限控制等)封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可拓展性和可维护性。
AOP 当中的概念:
- 切入点(Pointcut)
在哪些类,哪些方法上切入(where) - 通知(Advice)
在方法执行的什么实际(when:方法前/方法后/方法前后)做什么(what:增强的功能) - 切面(Aspect)
切面 = 切入点 + 通知,通俗点就是:在什么时机,什么地方,做什么增强! - 织入(Weaving)
把切面加入到对象,并创建出代理对象的过程。(由 Spring 来完成)
1.创建ProductService类
package service; /** * @author lenovo */ public class ProductService { public void doSomeService(){ System.out.println("doSomeService"); } }
2.xml文件中装配bean:
<?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 name="source" class="pojo.Source"> <property name="fruit" value="橙子"/> <property name="sugar" value="多糖"/> <property name="size" value="超大杯"/> </bean> <bean name="juickMaker" class="pojo.JuiceMaker"> <!-- 注意:这里要使用 ref 来注入另一个对象--> <property name="source" ref="source" /> </bean> <!--引入productService--> <bean name="productService" class="service.ProductService" /> </beans>
3SpringTest 中添加如下代码:
package test; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import service.ProductService; /** * @author lenovo */ public class SpringTest { @Test public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext( new String[]{"beans.xml"} ); ProductService s = (ProductService) context.getBean("productService"); s.doSomeService(); } }
4.运行测试类:
结果:
doSomeService