【转载】Spring学习(1)——快速入门--2019.05.19
认识 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 程序
- 新建一个空的 java 项目,命名为【spring】
- 新建一个名为【lib】的目录,并添加进必要的 jar 包,导入项目
- 在 packge【pojo】下新建一个【source】类:
package pojo; public class source { private string fruit; // 类型 private string sugar; // 糖分描述 private string size; // 大小杯 /* setter and getter */ }
- 在 【src】 目录下新建一个 【applicationcontext.xml】 文件,通过 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> </beans>
- 在 packge【test】下新建一个【testspring】类:
package test; import org.junit.test; import org.springframework.context.applicationcontext; import org.springframework.context.support.classpathxmlapplicationcontext; import pojo.source; public class testspring { @test public void test(){ applicationcontext context = new classpathxmlapplicationcontext( new string[]{"applicationcontext.xml"} ); source source = (source) context.getbean("source"); system.out.println(source.getfruit()); system.out.println(source.getsugar()); system.out.println(source.getsize()); } }
- 运行测试代码,可以正常拿到 xml 配置的 bean
- 总结:
-
传统的方式:
通过new 关键字主动创建一个对象 -
ioc方式:
对象的生命周期由spring来管理,直接从spring那里去获取一个对象。 ioc是反转控制 (inversion of control)的缩写,就像控制权从本来在自己手里,交给了spring。
参考地址:
di:dependency injection(依赖注入)
- 指 spring 创建对象的过程中,将对象依赖属性(简单值,集合,对象)通过配置设值给该对象
继续上面的例子
- 在 packge【pojo】下新建一个【juicemaker】类:
package pojo; public class juicemaker { // 唯一关联了一个 source 对象 private source source = null; /* setter and getter */ public string makejuice(){ string juice = "xxx用户点了一杯" + source.getfruit() + source.getsugar() + source.getsize(); return juice; } }
- 在 xml 文件中配置 juicemaker 对象:
- 注意:这里要使用 ref 来注入另一个对象
<?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"> <property name="source" ref="source" /> </bean> </beans>
- 在 【testspring】 中添加如下代码:
package test; import org.junit.test; import org.springframework.context.applicationcontext; import org.springframework.context.support.classpathxmlapplicationcontext; import pojo.juicemaker; import pojo.source; public class testspring { @test public void test(){ applicationcontext context = new classpathxmlapplicationcontext( new string[]{"applicationcontext.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()); } }
- 运行测试代码:
总结:ioc 和 di 其实是同一个概念的不同角度描述,di 相对 ioc 而言,明确描述了“被注入对象依赖 ioc 容器配置依赖对象”
ioc 如何实现的
最后我们简单说说ioc是如何实现的。想象一下如果我们自己来实现这个依赖注入的功能,我们怎么来做? 无外乎:
- 读取标注或者配置文件,看看juicemaker依赖的是哪个source,拿到类名
- 使用反射的api,基于类名实例化对应的对象实例
- 将对象实例,通过构造函数或者 setter,传递给 juicemaker
我们发现其实自己来实现也不是很难,spring实际也就是这么做的。这么看的话其实ioc就是一个工厂模式的升级版!当然要做一个成熟的ioc框架,还是非常多细致的工作要做,spring不仅提供了一个已经成为业界标准的java ioc框架,还提供了更多强大的功能,所以大家就别去造*啦!希望了解ioc更多实现细节不妨通过学习spring的源码来加深理解!
引用地址:
spring aop 简介
如果说 ioc 是 spring 的核心,那么面向切面编程就是 spring 最为重要的功能之一了,在数据库事务中切面编程被广泛使用。
aop 即 aspect oriented program 面向切面编程
首先,在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能。
- 所谓的核心业务,比如登陆,增加数据,删除数据都叫核心业务
- 所谓的周边功能,比如性能统计,日志,事务管理等等
周边功能在 spring 的面向切面编程aop思想里,即被定义为切面
在面向切面编程aop的思想里面,核心业务功能和切面功能分别独立进行开发,然后把切面功能和核心业务功能 "编织" 在一起,这就叫aop
aop 的目的
aop能够将那些与业务无关,却为业务模块所共同调用的逻辑或责任(例如事务处理、日志管理、权限控制等)封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可拓展性和可维护性。
aop 当中的概念:
- 切入点(pointcut)
在哪些类,哪些方法上切入(where) - 通知(advice)
在方法执行的什么实际(when:方法前/方法后/方法前后)做什么(what:增强的功能) - 切面(aspect)
切面 = 切入点 + 通知,通俗点就是:在什么时机,什么地方,做什么增强! - 织入(weaving)
把切面加入到对象,并创建出代理对象的过程。(由 spring 来完成)
aop 编程
- 在 packge【service】下创建 【productservice】类:
package service; public class productservice { public void dosomeservice(){ system.out.println("dosomeservice"); } }
- 在 xml 文件中装配该 bean:
<bean name="productservice" class="service.productservice" />
- 在【testspring】中编写测试代码,运行:
- 在 packge【aspect】下准备日志切面 【loggeraspect】类:
package aspect; import org.aspectj.lang.proceedingjoinpoint; public class loggeraspect { public object log(proceedingjoinpoint joinpoint) throws throwable { system.out.println("start log:" + joinpoint.getsignature().getname()); object object = joinpoint.proceed(); system.out.println("end log:" + joinpoint.getsignature().getname()); return object; } }
- 在 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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xsi:schemalocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <bean name="productservice" class="service.productservice" /> <bean id="loggeraspect" class="aspect.loggeraspect"/> <!-- 配置aop --> <aop:config> <!-- where:在哪些地方(包.类.方法)做增加 --> <aop:pointcut id="loggercutpoint" expression="execution(* service.productservice.*(..)) "/> <!-- what:做什么增强 --> <aop:aspect id="logaspect" ref="loggeraspect"> <!-- when:在什么时机(方法前/后/前后) --> <aop:around pointcut-ref="loggercutpoint" method="log"/> </aop:aspect> </aop:config> </beans>
- 再次运行 testspring 中的测试代码,代码并没有改变,但是在业务方法运行之前和运行之后,都分别输出了日志信息:
欢迎转载,转载请注明出处!
简书id:
github:
欢迎关注公众微信号:@程序员的文娱情怀
分享自己的文娱和互联网编程知识
上一篇: python中的__enter__ __exit__
下一篇: 即刻起,加速您的前端构建