spring框架基础之一

认识 Spring 框架

Spring 框架是 Java 应用最广的框架&＃xff0c;它的成功来源于理念&＃xff0c;而不是技术本身&＃xff0c;它的理念包括 IoC (Inversion of Control&＃xff0c;控制反转) 和 AOP(Aspect Oriented Programming&＃xff0c;面向切面编程)。

什么是 Spring&＃xff1a;

1. Spring 是一个轻量级的 DI / IoC 和 AOP 容器的开源框架&＃xff0c;来源于 Rod Johnson 在其著作《Expert one on one J2EE design and development》中阐述的部分理念和原型衍生而来。
2. Spring 提倡以“最少侵入”的方式来管理应用中的代码&＃xff0c;这意味着我们可以随时安装或者卸载 Spring

• 适用范围&＃xff1a;任何 Java 应用
• Spring 的根本使命&＃xff1a;简化 Java 开发

尽管 J2EE 能够赶上 Spring 的步伐&＃xff0c;但 Spring 并没有停止前进&＃xff0c; Spring 继续在其他领域发展&＃xff0c;而 J2EE 则刚刚开始涉及这些领域&＃xff0c;或者还没有完全开始在这些领域的创新。移动开发、社交 API 集成、NoSQL 数据库、云计算以及大数据都是 Spring 正在涉足和创新的领域。Spring 的前景依然会很美好。

Spring 中常用术语&＃xff1a;

• 框架&＃xff1a;是能完成一定功能的半成品。
  框架能够帮助我们完成的是&＃xff1a;项目的整体框架、一些基础功能、规定了类和对象如何创建&＃xff0c;如何协作等&＃xff0c;当我们开发一个项目时&＃xff0c;框架帮助我们完成了一部分功能&＃xff0c;我们自己再完成一部分&＃xff0c;那这个项目就完成了。
• 非侵入式设计&＃xff1a;
  从框架的角度可以理解为&＃xff1a;无需继承框架提供的任何类
  这样我们在更换框架时&＃xff0c;之前写过的代码几乎可以继续使用。
• 轻量级和重量级&＃xff1a;
  轻量级是相对于重量级而言的&＃xff0c;轻量级一般就是非入侵性的、所依赖的东西非常少、资源占用非常少、部署简单等等&＃xff0c;其实就是比较容易使用&＃xff0c;而重量级正好相反。
• JavaBean&＃xff1a;
  即符合 JavaBean 规范的 Java 类
• POJO&＃xff1a;即 Plain Old Java Objects&＃xff0c;简单老式 Java 对象
  它可以包含业务逻辑或持久化逻辑&＃xff0c;但不担当任何特殊角色且不继承或不实现任何其它Java框架的类或接口。

注意&＃xff1a;bean 的各种名称——虽然 Spring 用 bean 或者 JavaBean 来表示应用组件&＃xff0c;但并不意味着 Spring 组件必须遵循 JavaBean 规范&＃xff0c;一个 Spring 组件可以是任意形式的 POJO。

• 容器&＃xff1a;
  在日常生活中容器就是一种盛放东西的器具&＃xff0c;从程序设计角度看就是装对象的的对象&＃xff0c;因为存在放入、拿出等操作&＃xff0c;所以容器还要管理对象的生命周期。

Spring 的优势

• 低侵入 / 低耦合 &＃xff08;降低组件之间的耦合度&＃xff0c;实现软件各层之间的解耦&＃xff09;
• 声明式事务管理&＃xff08;基于切面和惯例&＃xff09;
• 方便集成其他框架&＃xff08;如MyBatis、Hibernate&＃xff09;
• 降低 Java 开发难度
• Spring 框架中包括了 J2EE 三层的每一层的解决方案&＃xff08;一站式&＃xff09;

Spring 能帮我们做什么

①.Spring 能帮我们根据配置文件创建及组装对象之间的依赖关系。
②.Spring 面向切面编程能帮助我们无耦合的实现日志记录&＃xff0c;性能统计&＃xff0c;安全控制。
③.Spring 能非常简单的帮我们管理数据库事务。
④.Spring 还提供了与第三方数据访问框架&＃xff08;如Hibernate、JPA&＃xff09;无缝集成&＃xff0c;而且自己也提供了一套JDBC访问模板来方便数据库访问。
⑤.Spring 还提供与第三方Web&＃xff08;如Struts1/2、JSF&＃xff09;框架无缝集成&＃xff0c;而且自己也提供了一套Spring MVC框架&＃xff0c;来方便web层搭建。
⑥.Spring 能方便的与Java EE&＃xff08;如Java Mail、任务调度&＃xff09;整合&＃xff0c;与更多技术整合&＃xff08;比如缓存框架&＃xff09;。

Spring 的框架结构

• Data Access/Integration层包含有JDBC、ORM、OXM、JMS和Transaction模块。
• Web层包含了Web、Web-Servlet、WebSocket、Web-Porlet模块。
• AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现。
• Core Container(核心容器)&＃xff1a;包含有Beans、Core、Context和SpEL模块。
• Test模块支持使用JUnit和TestNG对Spring组件进行测试。

Spring IoC 和 DI 简介

IoC&＃xff1a;Inverse of Control&＃xff08;控制反转&＃xff09;

• 读作“反转控制”&＃xff0c;更好理解&＃xff0c;不是什么技术&＃xff0c;而是一种设计思想&＃xff0c;就是将原本在程序中手动创建对象的控制权&＃xff0c;交由Spring框架来管理。
• 正控&＃xff1a;若要使用某个对象&＃xff0c;需要自己去负责对象的创建
• 反控&＃xff1a;若要使用某个对象&＃xff0c;只需要从 Spring 容器中获取需要使用的对象&＃xff0c;不关心对象的创建过程&＃xff0c;也就是把创建对象的控制权反转给了Spring框架
• 好莱坞法则&＃xff1a;Don’t call me ,I’ll call you

一个例子

控制反转显然是一个抽象的概念&＃xff0c;我们举一个鲜明的例子来说明。

在现实生活中&＃xff0c;人们要用到一样东西的时候&＃xff0c;第一反应就是去找到这件东西&＃xff0c;比如想喝新鲜橙汁&＃xff0c;在没有饮品店的日子里&＃xff0c;最直观的做法就是&＃xff1a;买果汁机、买橙子&＃xff0c;然后准备开水。值得注意的是&＃xff1a;这些都是你自己“主动”创造的过程&＃xff0c;也就是说一杯橙汁需要你自己创造。

然而到了今时今日&＃xff0c;由于饮品店的盛行&＃xff0c;当我们想喝橙汁时&＃xff0c;第一想法就转换成了找到饮品店的联系方式&＃xff0c;通过电话等渠道描述你的需要、地址、联系方式等&＃xff0c;下订单等待&＃xff0c;过一会儿就会有人送来橙汁了。

请注意你并没有“主动”去创造橙汁&＃xff0c;橙汁是由饮品店创造的&＃xff0c;而不是你&＃xff0c;然而也完全达到了你的要求&＃xff0c;甚至比你创造的要好上那么一些。

编写第一个 Spring 程序

1. 新建一个空的 Java 项目&＃xff0c;命名为【spring】
2. 新建一个名为【lib】的目录&＃xff0c;并添加进必要的 jar 包&＃xff0c;导入项目

1. 在 Packge【pojo】下新建一个【Source】类&＃xff1a;

package pojo;public class Source { private String fruit; // 类型private String sugar; // 糖分描述private String size; // 大小杯 /* setter and getter */
}

1. 在 【src】 目录下新建一个 【applicationContext.xml】 文件&＃xff0c;通过 xml 文件配置的方式装配我们的 bean

1. 在 Packge【test】下新建一个【TestSpring】类&＃xff1a;

package test;import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.Source;public class TestSpring {&＃64;Testpublic void test(){ApplicationContext context &＃61; new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});Source source &＃61; (Source) context.getBean("source");System.out.println(source.getFruit());System.out.println(source.getSugar());System.out.println(source.getSize());}
}

1. 运行测试代码&＃xff0c;可以正常拿到 xml 配置的 bean

• 总结&＃xff1a;
• 传统的方式&＃xff1a;
  通过new 关键字主动创建一个对象
• IOC方式&＃xff1a;
  对象的生命周期由Spring来管理&＃xff0c;直接从Spring那里去获取一个对象。 IOC是反转控制 (Inversion Of Control)的缩写&＃xff0c;就像控制权从本来在自己手里&＃xff0c;交给了Spring。
  

参考地址&＃xff1a;这里

DI&＃xff1a;Dependency Injection&＃xff08;依赖注入&＃xff09;

• 指 Spring 创建对象的过程中&＃xff0c;将对象依赖属性&＃xff08;简单值&＃xff0c;集合&＃xff0c;对象&＃xff09;通过配置设值给该对象

继续上面的例子

1. 在 Packge【pojo】下新建一个【JuiceMaker】类&＃xff1a;

package pojo;public class JuiceMaker {// 唯一关联了一个 Source 对象private Source source &＃61; null;/* setter and getter */public String makeJuice(){String juice &＃61; "xxx用户点了一杯" &＃43; source.getFruit() &＃43; source.getSugar() &＃43; source.getSize();return juice;}
}

1. 在 xml 文件中配置 JuiceMaker 对象&＃xff1a;

• 注意&＃xff1a;这里要使用 ref 来注入另一个对象

1. 在 【TestSpring】 中添加如下代码&＃xff1a;

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 {&＃64;Testpublic void test(){ApplicationContext context &＃61; new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});Source source &＃61; (Source) context.getBean("source");System.out.println(source.getFruit());System.out.println(source.getSugar());System.out.println(source.getSize());JuiceMaker juiceMaker &＃61; (JuiceMaker) context.getBean("juickMaker");System.out.println(juiceMaker.makeJuice());}
}

1. 运行测试代码&＃xff1a;

总结&＃xff1a;IoC 和 DI 其实是同一个概念的不同角度描述&＃xff0c;DI 相对 IoC 而言&＃xff0c;明确描述了“被注入对象依赖 IoC 容器配置依赖对象”

IoC 如何实现的

最后我们简单说说IoC是如何实现的。想象一下如果我们自己来实现这个依赖注入的功能&＃xff0c;我们怎么来做&＃xff1f; 无外乎&＃xff1a;

1. 读取标注或者配置文件&＃xff0c;看看JuiceMaker依赖的是哪个Source&＃xff0c;拿到类名
2. 使用反射的API&＃xff0c;基于类名实例化对应的对象实例
3. 将对象实例&＃xff0c;通过构造函数或者 setter&＃xff0c;传递给 JuiceMaker

我们发现其实自己来实现也不是很难&＃xff0c;Spring实际也就是这么做的。这么看的话其实IoC就是一个工厂模式的升级版&＃xff01;当然要做一个成熟的IoC框架&＃xff0c;还是非常多细致的工作要做&＃xff0c;Spring不仅提供了一个已经成为业界标准的Java IoC框架&＃xff0c;还提供了更多强大的功能&＃xff0c;所以大家就别去造轮子啦&＃xff01;希望了解IoC更多实现细节不妨通过学习Spring的源码来加深理解&＃xff01;

引用地址&＃xff1a;这里

Spring AOP 简介

如果说 IoC 是 Spring 的核心&＃xff0c;那么面向切面编程就是 Spring 最为重要的功能之一了&＃xff0c;在数据库事务中切面编程被广泛使用。

AOP 即 Aspect Oriented Program 面向切面编程

首先&＃xff0c;在面向切面编程的思想里面&＃xff0c;把功能分为核心业务功能&＃xff0c;和周边功能。

• 所谓的核心业务&＃xff0c;比如登陆&＃xff0c;增加数据&＃xff0c;删除数据都叫核心业务
• 所谓的周边功能&＃xff0c;比如性能统计&＃xff0c;日志&＃xff0c;事务管理等等

周边功能在 Spring 的面向切面编程AOP思想里&＃xff0c;即被定义为切面

在面向切面编程AOP的思想里面&＃xff0c;核心业务功能和切面功能分别独立进行开发&＃xff0c;然后把切面功能和核心业务功能 "编织" 在一起&＃xff0c;这就叫AOP

AOP 的目的

AOP能够将那些与业务无关&＃xff0c;却为业务模块所共同调用的逻辑或责任&＃xff08;例如事务处理、日志管理、权限控制等&＃xff09;封装起来&＃xff0c;便于减少系统的重复代码&＃xff0c;降低模块间的耦合度&＃xff0c;并有利于未来的可拓展性和可维护性。

AOP 当中的概念&＃xff1a;

• 切入点&＃xff08;Pointcut&＃xff09;
  在哪些类&＃xff0c;哪些方法上切入&＃xff08;where&＃xff09;
• 通知&＃xff08;Advice&＃xff09;
  在方法执行的什么实际&＃xff08;when:方法前/方法后/方法前后&＃xff09;做什么&＃xff08;what:增强的功能&＃xff09;
• 切面&＃xff08;Aspect&＃xff09;
  切面 &＃61; 切入点 &＃43; 通知&＃xff0c;通俗点就是&＃xff1a;在什么时机&＃xff0c;什么地方&＃xff0c;做什么增强&＃xff01;
• 织入&＃xff08;Weaving&＃xff09;
  把切面加入到对象&＃xff0c;并创建出代理对象的过程。&＃xff08;由 Spring 来完成&＃xff09;

AOP 编程

1. 在 Packge【service】下创建 【ProductService】类&＃xff1a;

package service;public class ProductService {public void doSomeService(){System.out.println("doSomeService");}
}

1. 在 xml 文件中装配该 bean&＃xff1a;

1. 在【TestSpring】中编写测试代码&＃xff0c;运行&＃xff1a;

1. 在 Packge【aspect】下准备日志切面 【LoggerAspect】类&＃xff1a;

package aspect;import org.aspectj.lang.ProceedingJoinPoint;public class LoggerAspect {public Object log(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("start log:" &＃43; joinPoint.getSignature().getName());Object object &＃61; joinPoint.proceed();System.out.println("end log:" &＃43; joinPoint.getSignature().getName());return object;}
}

1. 在 xml 文件中声明业务对象和日志切面&＃xff1a;

1. 再次运行 TestSpring 中的测试代码&＃xff0c;代码并没有改变&＃xff0c;但是在业务方法运行之前和运行之后&＃xff0c;都分别输出了日志信息&＃xff1a;

参考&＃xff1a;https://www.cnblogs.com/wmyskxz/p/8820371.html