Spring的总结
Spring的核心:
1. Spring的两大核心:
1. IOC: 控制反转,将创建(实例化)对象的权利交给Spring容器去进行管理.
2. AOP: 面向切面编程(将切面织入到连接点,使连接点称为切入点).
2. Spring是一线式框架:
简单的来说,可以单单使用Spring实现MVC三层架构,Mybtais的数据访问层可以使用JdbcTemplate来代替.web层有SpringMVC,Spring贯穿了三层架构.
3. IOC:
* IOC的目的是实现解耦,来降低程序的耦合度(高内聚,低耦合).
* 实现的思想是: 反射 + 配置文件 + 工厂,使用工厂来读取配置文件,利用反射来实例化对象.
4. 初始化Spring容器:
* ApplicationContext的三个实现接口:
1. ClassPathXmlApplicationContext: 从类路径下加载配置文件
2. FileSystemXmlApplicationContext: 从文件系统中加载配置文件
3. AnnotationConfigApplicationContext: 注解开发
* ApplicationContext与BeanFactory的区别和联系:
ApplicationContext是BeanFactory的子接口(BeanFactory是ApplicationContext的*父接口).
ApplicationContext采用立即加载的方式,加载配置文件的时候就初始化bean.
BeanFactory采用延迟加载,使用bean的时候才会初始化.
ApplicationContext还实现了其他的接口,具有更为丰富的功能(国际化,自动装配等)
5. Bean的实例化的三种方式:
<!--初始化Bean有三种方式
1. 使用Bean的id class,需要默认的构造方法
-->
<bean id="testService" class="cn.itcast.spring.service.impl.TestServiceImpl"></bean>
<!--第二种方式 使用BeanFactory的普通方法-->
<bean id="factory" class="cn.itcast.spring.BeanFactory"></bean>
<bean id="testService2" factory-bean="factory" factory-method="getBean"></bean>
<!--第三种方法 使用BeanFactory的静态方法-->
<bean id="testService3" class="cn.itcast.spring.BeanFactory" factory-method="getStaticBean"></bean>
6. Bean的作用范围:
singleton: 单例的(Spring的默认),在IOC容器中唯一
prototype: 多例的,每次获取bean都是新对象
request: 在web开发中,与request域绑定,获取的bean作为request的属性
session: 在web开发中,与session域进行绑定,获取的bean作为session的属性
global-session: 在web开发中,在集群环境下,才可以使用,如果是单个服务器,与session没有区别.
7. Bean的生命周期(指定init-method和destroy-method):
单例:
初始化:加载配置文件的时候初始化,执行init-method方法
活着:容器存在,Bean存在
销毁:容器销毁,Bean消失,执行destroy-method方法.
总结: 单例模式的Bean的生命周期与容器相同(容器的销毁需要手动销毁).
多例:
初始化: 调用getBean使用的时候初始化
活着:对象使用就一直活着
销毁:有java的JVM的垃圾回收机制决定
总结:使用时初始化,销毁由JVM的垃圾回收机制决定
Spring的DI
2. 注入的三种方式
* 构造器注入(constructor-arg标签),必须指定构造函数所有的参数
1. type:根据参数的类型来注入数据
2. index:根据参数的索引来注入,从0开始
3. name:根据参数的名称来注入数据(建议使用)
4. value:只能注入基本类型,基本类型的包装类和String
5. ref:用于注入其他的Bean类型数据(尤其注意Date类型)
* setter注入(依赖于set方法,使用property标签)----重要
1. name:用于指定注入时所调用的set方法后面的变量名称
2. value:注入基本类型,基本类型的包装类和String
3. ref:用于注入其他的Bean类型数据(尤其注意Date类型<bean id="now" class="java.util.Date"></bean>)
* 注解注入
3. 集合的注入(前三个为值类型的集合,后两个为键值对类型的集合,同类型的集合,使用的标签可以互换,但是建议使用的时候标签与实际类型对应)
* 数组
<property name="myArrs">
<array>
<value>AAA</value>
<value>BBB</value>
</array>
</property>
* List集合
<property name="myLists">
<list>
<value>AAA</value>
<value>BBB</value>
</list>
</property>
* Set集合
<property name="mySets">
<set>
<value>AAA</value>
<value>BBB</value>
</set>
</property>
* Map
<property name="myMaps">
<map>
<!--如果是复杂数据类型,可以使用key-ref和value-ref-->
<entry key="testA" value="AAA"></entry>
<entry key="testB" value="BBB"></entry>
</map>
</property>
* Properties
<property name="properties">
<props>
<prop key="testA">AAA</prop>
<prop key="testB">BBB</prop>
</props>
</property>
Spring的IOC注解 + xml
1. Spring的注解是为了替代xml配置文件而开发的.
2. 在xml配置文件中,修改约束,并开启注解扫描
<context:component-scan base-package=""/>
3. 注解定义容器中的Bean
@Component ----> 如果不指定value,默认的bean的名称是类名的首字母小写,指定value属性bean的名称就是指定的值
@Controller ----> 作用于表现层
@Service ---> 作用于业务层
@Repository ---> 作用于数据访问层
4. 注入属性的注解
@Autowired: 按照类型注入,多个类型使用变量名来判定注入的bean.
@Qualifiler: 配合@Autoeired注解完成注入,一起使用,使用该注解指定注入的名称.
@Resource注解指定name属性来指定注入的名称
@Value: 用于注入基本类型和String,上面三种是注入其他的Bean的.
5. @Scope的注解是指定作用范围
singleton: 单例
prototype: 多例
request
session
global-session
6. 生命周期的注解:
@PostConstruct: 指定初始化
@PreDestroy: 指定销毁方法
全注解方式
1. 在前面的开发基础上,替换xml文件,使用配置类
配置类就是使用@Configuration注解标识的类
2. 那包扫描使用哪个注解?
@ComponentScan : 指定扫描的包
3. @Bean: 在方法上使用,可以将返回的值对象放入Spring容器中,需要指定name属性
4. 使用注解开发如何加载Spring的容器呢?
想到ApplicatoinContext的三个实现类的第三个,使用AnnotationConfigApplicationCOntext(配置类的字节码)来获取Spring容器
5. 关于配置类的相关注解
* @Configuration
* @Import : 导入子配置类,使用该注解的类是总配置类
* @ComponentScan : 指定扫描的包
* @Bean: 在方法上使用,可以将返回的值对象放入Spring容器中,需要指定name属性
* @PropertySource: 指定文件的名称和路径 @PropertySource("classpath:jdbcConfig.properties")
* @Qualifiler 用于方法参数,可以指定注入的值,用于多个数据源等参数有多个实现类的情况.
6. 为什么使用子配置类
将同一个业务的代码放在同比一个配置文件,不同的业务放在不同的配置文件,高内聚. 所以使用子配置类,总配置类使用@Import注解来加载子配置类
Spring整个Junit
1. 两个注解
@Runwith
@ContextConfiguration
SpringAOP
1. 概念:
AOP: 面向切面编程,与OOP类似,是一种编程思想(AspectJ是基于AOP思想的一种技术)
作用: 在不更改源码的情况下,对原始方法进行增强
底层原理: 使用动态代理实现
2. 相关术语:
Joinpoint(连接点): 简单来说业务层接口的所有的方法都可以作为连接点
Pointcut(切入点): 实际被切面织入的连接点(被增强的方法)
Advice(通知): 切面的整个实现(切面织入的目标对象,时间点以及内容),通知是共性代码抽取出来的方法
前置,后置,异常,最终,环绕
Target(目标对象): 切入点和连接点所属的类
weaving(织入): 将切面代码插入到目标对象的某个方法的过程
Aspect(切面): 交叉在各个业务逻辑中的系统服务,类似于安全验证,事务处理等等
Advisor(顾问): 就是通知的封装和延伸,可以将通知以更为复杂的方式织入到某些方法中去
Proxy(代理): 创建代理对象的整个过程
3. 简单总结:
将切面织入到连接点,使得连接点成为切入点
SpringAOP的XML的配置
最前面,pom.xml的配置文件引入的依赖:
spring-context
spring-tx
spring-jdbc
mysql-connection-java
aspectjweaver
spring-test
junit
1. 核心配置文件的内容
1. 目标类的Bean的注入
2. 通知类的Bean的注入
3. 表明AOP的配置 <aop:config>
4. 在config的内部配置切面 <aop:aspect>
注意的属性有两个,一个是id(唯一标识),一个是ref(指向通知类).
5. 在aspect内部配置通知类型
前置通知
后置通知
异常通知
最终通知
环绕通知
注意两个属性:
method: 指明通知(也就是注入的方法)
pointcut: 指明切入点(使用切入点表达式 * 包名.包名..*.*(..))
6. 可以统一配置切入点表达式<aop:pointcut>,两个属性注意
id: 唯一标识
expression: 配置切入点表达式
SpringAOP的注解的配置
1. 核心配置文件:
1. 开启注解扫描: <context:component-scan base-package="com.itheima"></context:component-scan>
2. 开启Spring对AOP注解的支持 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
2. 对于目标类,需要添加bean的注解
3. 通知类需要添加bean的注解支持
1. 通知类需要添加切面注解 @Aspect
2. 通知类需要定义切面表达式(利用方法,唯一标识就是方法名)
3. 对通知添加通知类型的注解(前置,后置,最终,异常,环绕),注意的是环绕通知的ProceedingJoinPoint
4. 测试类:
使用ClassPathXmlApplicationContext来创建ApplicationContext的实例
5. 注意顺序问题:
对于注解来说,前置,后置,最终,异常的顺序是=====> 前置 -> 最终 -> 后置 注意的是后置和异常同一时刻只能执行一个,如果有环绕通知,环绕通知最先执行
我是前置通知
添加账户
我是最终通知
我是后置通知
有异常的时候:
我是前置通知
添加账户
我是最终通知
我是异常通知
环绕通知的应用场景:
事务管理
日志记录
性能检测
SpringJdbcTemplate
1. 首先引入依赖:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
2. 对于dao接口的实现类,继承JdbcDaoSupport,直接使用getJdbcTemplate()就可以获取JdbcTemplate对象
3. 核心配置文件的配置:
1. 注入数据访问层接口实现类的bean,中间使用setter注入JdbcTemplate
2. 注入JdbcTemplate的bean,中间使用setter注入DataSource
3. 注入dataSource,使用Spring自带的连接池DriverManagerDataSource,使用setter注入四要素
4. 测试执行就好
Spring事务管理
1. 事务控制在业务(Service)层
2. Spring事务管理的API三大接口 -----> spring-tx包下
1. PlatformTransactionManager : 平台事务管理器
DataSourceTransactionManager ----> springjdbc,mybatis
HibernateTransactionManager ----> hibernate
2. TransactionDefinition : 事务定义接口(包含了事务的基本属性信息)
3. TransactionStatus : 事务状态接口(事务状态的一些基本信息)
3. 事务管理的方式:
* 声明式事务管理(重点掌握)
1. XML
2. 注解
* 编程式事务管理(了解)
事务管理之环境依赖
1. 环境搭建(依赖):
spring-context : 核心
spring-tx : 事务管理
spring-jdbc : 数据库
mysql-connection-java : 数据库连接
aspectjweave : aop
spring-test : 测试,与junit进行整合
junit : 测试
事务管理之基于XML的声明式事务控制
pom文件的依赖：
spring-context
spring-tx
spring-jdbc
mysql-connection-java
aspectjweaver
spring-test
junit
1. 核心配置文件配置(aop,tx的约束):
1. 声明service的bean（注入dao）
2. 声明dao的bean（注入dataSource），dao实现类继承JdbcDaoSupport，使用Spring提供的模板
3. 声明dataSource，使用spring的连接池 DriverManagerDataSource，注入四要素
4. 配置事务管理器(<bean>) DataSourceTransactionManager，需要注入dataSource
5. 配置事务的通知 <tx:advice>,其实就是事务管理的通知
id属性: 唯一标识
transaction-manager: 给事务通知提供一个事务管理器的引用
6. 配置AOP的通用切入点表达式<aop:config>
配置切入点表达式 <aop:pointcut>
建立切入点表达式与事务通知之间的关系 <aop:advisor>,内部其实是环绕通知
advice_ref
pointcut-ref
7. 配置事务的属性(在事务通知标签内部配置)
<tx:attribute><tx:method name="find*" propagation="" read-only="" /></tx:attribute>,name用来配置方法,可以使用表达式
isolation: 事务的隔离级别,默认值是default
propagation: 指定事务的传播行为,默认是REQUIRED,表示一定会有事务,增删改的选择.如果是查询,可以说那个SUPPORTS
read-only: 用于指定事务是否只读,只有查询方法才能设置为true,默认是false,表示读写
timeout: 指定事务的超时时间,默认值是-1,表示永不超时,单位是秒
rollback-for: 用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚。没有默认值。默认回滚运行期异常
no-rollback-for: 用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时事务回滚。没有默认值。默认回滚运行期异常
8. 测试的时候使用Junit和Spring的整合进行测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:bean.xml"})
public class TxTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer(){
accountService.tranfer("aaa","bbb",100f);
}
}
如果使用main方法进行测试注意的是获取bean的时候获取的应该是接口，因为使用的是java的动态代理，获取的代理对象与原来对象的关系是兄弟关系，如果直接获取实现类的对象，会报代理异常错误
2. 关于Spring事务控制异常回滚
默认回滚运行期异常,如果想要控制非运行期异常也回滚,则使用rollback-for="java.lang.Exception"来指定,指定多个异常使用逗号隔开
事务管理之基于注解的事务控制（在前一个项目的基础上修改）
1. 核心配置文件(aop,tx,context)
1. 开启注解扫描: <context:component-scan>
2. 配置平台事务管理器 <bean>指定事务管理器 DataSourceTransactionManager
3. 开启Spring对注解事务的支持: <tx:annotation-driver transaction-manager="">
4. 在目标类上面添加 @Transactional() 还可以配置属性，属性一般都有默认值，可以查看源码试试
注意的是 @Transactional()可以指定在方法上面,单独为这个方法指定事务属性
2. 替换核心配置文件的内容：
1. 替换service的bean的注入
2. 删除事务通知和AOP切面就可以了
3. 直接进行测试
4. @Transactional作用位置的区别
> 作用于类上,当前类所有的方法具有事务控制
> 作用在方法上,当前类的所有方法都具有事务
> 接口上,当前接口的实现类的所有方法具有事务
Spring的全注解配置方式(使用下面的方式替换xml配置文件)
首先先删除xml配置文件
1. 核心配置类
@Configuration
@ComponentScan
@Import // 导入其他两个配置文件
@PropertySource({"classpath:"})
@EnableTransactionMangement // 开启事务注解支持
2. 子配置类(两个子配置类，一个事务，一个JDBC连接)
@Configuration
@Bean(name="")
@Value
在jdbc连接配置类中配置DataSource和JdbcTemplate
在事务配置类中配置 用于创建事务管理器对象PlatformTransactionManager Bean的名字为transactionManager
