目录
- 一、什么是Spring
- 二、什么是IOC
- 三、快速搭建框架环境
- 四、spring之依赖注入
- 五、详解Spring框架的IOC之注解方式
- 七、Spring之JDBC
- 八、Spring之事务
- 九、Spring框架的事务管理之编程式的事务管理
- 十、Spring框架的事务管理之声明式事务管理,即通过配置文件来完成事务管理(AOP思想)
一、什么是Spring
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言,绝大部分Java应用都可以从Spring中受益。Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。
◆目的:解决企业应用开发的复杂性
◆功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能
◆范围:任何Java应用
二、什么是IOC
控制反转(Inversion of Control,英文缩写为IoC)把创建对象的权利交给框架,是框架的重要特征,并非面向对象编程的专用术语。它包括依赖注入和依赖查找。传统的业务层,当需要资源时就在该业务层new资源,这样耦合性(程序之间相互依赖关联)较高。现在将new的部分交给spring,做到高内聚低耦合。简而言之:原先是每当调用dao层或service层方法时,由app来new,现在是将new的权利交给spring,要什么资源从spring中获取!
三、快速搭建框架环境
1.下载框架所需的依赖jar包
spring官网为:http://spring.io/
下载jar包: http://repo.springsource.org/libs-release-local/org/springframework/spring
2.导入基本jar包
![](https://img.laitimes.com/img/_0nNw4CM6IyYiwiM6ICdiwiIn5GcuETM1ITM5AzMwQDM4EDMy8CX0ADOxAjMvwVZsNWa0JXYvw1cldWYtl2XlxWam9CX0VmbuETNipmLzVGbpZ2Lc9CX6MHc0RHaiojIsJye.png)
其实基本核心jar有beans;context;core;expression包,其他是依赖log4j日志。当然spring的jar不止这些,后期慢慢加上。
3.配置log4j配置文件
日志文件定义在src目录下
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | |
4.测试日志文件是否部署成功
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | |
5.定义一个接口和实现类
接口:
?
1 2 3 4 5 | |
实现类
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | |
6.定义spring专属的配置文件
定义名为applicationContext.xml,位置为src下,与日志文件同目录,导入相对应的约束,并将实现类注入到配置文件中,刚开始入门,使用bean约束
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | |
7.测试
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 | |
其中旧工厂与新工厂的区别
* BeanFactory和ApplicationContext的区别
* BeanFactory -- BeanFactory采取延迟加载,第一次getBean时才会初始化Bean
* ApplicationContext -- 在加载applicationContext.xml时候就会创建具体的Bean对象的实例,还提供了一些其他的功能
* 事件传递
* Bean自动装配
* 各种不同应用层的Context实现
总结:这是个最基本的demo,是将实现类配置到了spring配置文件中,每次启动服务器时,就会加载配置文件,从而实例化了实现类
四、spring之依赖注入
1、什么是依赖注入?
Spring 能有效地组织J2EE应用各层的对象。不管是控制层的Action对象,还是业务层的Service对象,还是持久层的DAO对象,都可在Spring的 管理下有机地协调、运行。Spring将各层的对象以松耦合的方式组织在一起,Action对象无须关心Service对象的具体实现,Service对 象无须关心持久层对象的具体实现,各层对象的调用完全面向接口。当系统需要重构时,代码的改写量将大大减少。依赖注入让bean与bean之间以配置文件组织在一起,而不是以硬编码的方式耦合在一起。理解依赖注入
依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例,调用者)需要另一个角色(另一个Java实例,被调用者)的协助时,在 传统的程序设计过程中,通常由调用者来创建被调用者的实例。但在Spring里,创建被调用者的工作不再由调用者来完成,因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成,然后注入调用者,因此也称为依赖注入。
不管是依赖注入,还是控制反转,都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互相透明。
2. IOC和DI的概念
* IOC -- Inverse of Control,控制反转,将对象的创建权反转给Spring!!
* DI -- Dependency Injection,依赖注入,在Spring框架负责创建Bean对象时,动态的将依赖对象注入到Bean组件中!!
3.演示
对于类成员变量,常用的注入方式有两种
属性set方法注入和构造方法注入
先演示第一种:属性set方法注入
1)持久层
?
1 2 3 4 5 6 7 | |
2)业务层
注意:此时是想将持久层注入到业务层,将创建持久层实例权利交给框架,条件是业务层必须提供持久层的成员属性和set方法
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | |
3)配置文件配置
?
1 2 3 4 5 6 | |
4)测试
?
1 2 3 4 5 6 7 8 9 10 11 | |
第二种:构造方法注入
1)pojo类并提供构造方法
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | |
2)配置文件配置
?
1 2 3 4 5 6 7 8 | |
3)测试
?
1 2 3 4 5 6 | |
拓展:构造方法之将一个对象注入到另一个对象中
1)pojo类:目的:将上列中的车注入到人类,使之成为其中一个属性,则必须在此类中提供车的成员属性,并提供有参构造方法
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | |
2)配置文件
?
1 2 3 4 5 | |
4.如何注入集合数组
1)定义pojo类
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 | |
2)配置文件
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | |
3)测试
?
1 2 3 4 5 6 7 8 9 | |
5.怎么分模块开发
在主配置文件加入<import>标签(假如此时在com.clj.test包下定义了一个配置文件applicationContext2.xml)
?
1 2 | |
五、详解Spring框架的IOC之注解方式
1、入门
1).导入jar包
除了先前6个包,玩注解还需一个spring-aop包
2).持久层和实现层(这里忽略接口)
持久层
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | |
业务层
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | |
3).定义配置文件
此时约束条件需添加context约束,并添加组件扫描
?
1 2 3 4 5 6 7 8 9 | |
4)在实现类中添加注解
?
1 2 3 4 5 6 7 8 9 | |
5)编写测试
?
1 2 3 4 5 6 7 8 9 | |
2.关于bean管理常用属性
1. @Component:组件.(作用在类上) 最原始的注解,所有需要注解的类都写这个没问题,他是通用的
2. Spring中提供@Component的三个衍生注解:(功能目前来讲是一致的)
* @Controller -- 作用在WEB层
* @Service -- 作用在业务层
* @Repository -- 作用在持久层
* 说明:这三个注解是为了让标注类本身的用途清晰,Spring在后续版本会对其增强
3. 属性注入的注解(说明:使用注解注入的方式,可以不用提供set方法)
* 如果是注入的普通类型,可以使用value注解
* @Value -- 用于注入普通类型
* 如果注入的是对象类型,使用如下注解
* @Autowired -- 默认按类型进行自动装配 匹配的是类型,与注入类的类名无关
* 如果想按名称注入
* @Qualifier -- 强制使用名称注入 必须与Autowired一起用,指定类名,与注入的类名有关
* @Resource -- 相当于@Autowired和@Qualifier一起使用
* 强调:Java提供的注解
* 属性使用name属性
4. Bean的作用范围注解
* 注解为@Scope(value="prototype"),作用在类上。值如下:
* singleton -- 单例,默认值
* prototype -- 多例
5. Bean的生命周期的配置(了解)
* 注解如下:
* @PostConstruct -- 相当于init-method
* @PreDestroy -- 相当于destroy-method
1.演示属性对象注解
条件:采用扫描的方式将属性(name)和对象(userDaoImpl)注入到业务层中
1)持久层开启注解扫描Repository
?
1 2 3 4 5 6 7 8 | |
2)业务层针对属性和对象提供注解
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 | |
3)配置文件只需要开启全部扫描即可
?
1 2 3 4 5 6 7 8 9 | |
注意:至于集合还是推荐使用配置文件方式
2.Spring框架整合JUnit单元测试
1)添加单元测试所需依赖包spring-test.jar
注意:基于myeclipes自带Junit环境,但是有时因为版本问题,可能需要比较新的Junit环境,这里我在网上下了一个教新的 Junit-4.9的jar包,如果myeclipes较新的话无须考虑
2)编写测试类,添加相对应的注解
@RunWith与@ContextConfiguration(此是用于加载配置文件,因为默认从WebRoot路径为一级目录,加上此是认定src为一级目录)
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | |
六.spring框架之AOP
1.什么是AOP
* 在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,功能模块化
* AOP是一种编程范式,隶属于软工范畴,指导开发者如何组织程序结构
* AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范
* 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术
* AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型
* 利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率
AOP采取横向抽取机制,取代了传统纵向继承体系重复性代码(性能监视、事务管理、安全检查、缓存)
2. 为什么要学习AOP
* 可以在不修改源代码的前提下,对程序进行增强!!(为固定的方法生成一个代理,在访问该方法之前,先进入代理,在代理中,可以编写更多的功能,使之方法的功能更强,使得程序进行增 强)
Aop:面向切面编程,将一切事模块化,每个模块比较独立,模块可以共用(相同的),不同的格外自定义。用此替代传统的面向纵向编程,提高程序的可重用性
3.AOP的实现(实现原理)
Aop的实现包含两种代理方式<1>实现类接口:采用JDK动态代理<2>未实现类接口:采用CGLIB动态代理
1.实现JDK动态代理
1)定义持久层接口实现类
?
1 2 3 4 5 6 | |
?
1 2 3 4 5 6 7 8 9 10 11 12 13 | |
2)定义JDK动态代理工具类
此工具类是在执行持久层save方法时增加一些功能,在开发中做到在不更改源码情况下增强某方法
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | |
3)测试
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | |
2.实现CGLIB技术
1)定义持久层,此时没有接口
?
1 2 3 4 5 6 7 8 9 10 | |
2)编写工具类
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | |
3)编写测试类
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | |
3、Spring基于AspectJ的AOP的开发(配置文件方式)
1)部署环境,导入相对应的jar包
2)创建配置文件,并引入AOP约束
?
1 2 3 4 5 6 | |
3)创建接口和实现类
?
1 2 3 4 5 6 | |
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | |
4)定义切面类
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 | |
5)注入实现类和切面类
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | |
6)测试
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | |
扩展:切面类升级
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | |
4、Spring框架AOP之注解方式
1)创建接口和实现类
?
1 2 3 4 5 6 | |
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | |
2)定义切面类
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | |
3)配置切面类和实现类,并开启自动代理
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | |
七、Spring之JDBC
spring提供了JDBC模板:JdbcTemplate类
1.快速搭建
1)部署环境
这里在原有的jar包基础上,还要添加关乎jdbc的jar包,这里使用的是mysql驱动
2)配置内置连接池,将连接数据库程序交给框架管理,并配置Jdbc模板类
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | |
3)测试
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 | |
2、配置开源连接池
一般现在企业都是用一些主流的连接池,如c3p0和dbcp
首先配置dbcp
1)导入dbcp依赖jar包
2)编写配置文件
?
1 2 3 4 5 6 7 | |
将模板类中引入的内置类datasource改为开源连接池的
3)编写测试类
配置c3p0
1)导入c3p0依赖jar包
2)配置c3p0
?
1 2 3 4 5 6 7 | |
将模板类中引入的内置类datasource改为开源连接池的
3)编写测试类
八、Spring之事务
1、什么是事务
数据库事务(Database Transaction) ,是指作为单个逻辑工作单元执行的一系列操作,要么完全地执行,要么完全地不执行。 事务处理可以确保除非事务性单元内的所有操作都成功完成,否则不会永久更新面向数据的资源。通过将一组相关操作组合为一个要么全部成功要么全部失败的单元,可以简化错误恢复并使应用程序更加可靠。一个逻辑工作单元要成为事务,必须满足所谓的ACID(原子性、一致性、隔离性和持久性)属性。事务是数据库运行中的逻辑工作单位,由DBMS中的事务管理子系统负责事务的处理。
2、怎么解决事务安全性问题
读问题解决,设置数据库隔离级别;写问题解决可以使用 悲观锁和乐观锁的方式解决
3、快速开发
方式一:调用模板类,将模板注入持久层
1)编写相对应的持久层和也外层,这里省略接口
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | |
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | |
2)配置相对应的配置文件
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | |
3)测试类
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | |
方式二:持久层继承JdbcDaoSupport接口,此接口封装了模板类jdbcTemplate
1)编写配置文件
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | |
2)更改持久层
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | |
3)更改业务层
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | |
4)测试类和上述一样
4、spring事务管理
Spring为了简化事务管理的代码:提供了模板类 TransactionTemplate,手动编程的方式来管理事务,只需要使用该模板类即可!!
九、Spring框架的事务管理之编程式的事务管理
1、手动编程方式事务(了解原理)
1)快速部署,搭建配置文件,配置事务管理和事务管理模板,并在持久层注入事务管理模板
配置事务管理器
?
1 2 3 4 | |
配置事务管理模板
?
1 2 3 | |
将管理模板注入业务层
?
1 2 3 4 | |
全部代码:
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | |
2)在业务层使用模板事务管理
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | |
3)测试类和上一致
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | |
十、Spring框架的事务管理之声明式事务管理,即通过配置文件来完成事务管理(AOP思想)
申明式事务有两种方式:基于AspectJ的XML方式;基于AspectJ的注解方式
1、XML方式
1)配置配置文件
需要配置平台事务管理
?
1 2 3 4 5 6 7 8 9 10 11 | |
配置事务增强
?
1 2 3 4 5 6 7 | |
aop切面类
?
1 2 3 4 | |
全部代码
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | |
2)编写持久层和业务层(省略接口)
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | |
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | |
3)测试类
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | |
2、注解方式
1)配置配置文件
配置事务管理
?
1 2 3 4 5 6 7 8 9 | |
开启注释事务
?
1 2 | |
全部代码
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | |
2)业务层增加@Transactional
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | |
3)持久层不变
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | |
4)测试类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | |