Spring 核心组件总结

spring核心组件总结

spring介绍

spring概念

IOC: Inverse Of Control 控制反转

​ 将我们创建对象的方式反转了，以前创建对象是由我们开发人员自己维护，包括依赖注入关系也是自己注入。

​ 使用了spring之后，对象的创建以及依赖关系，由spring完成创建以及注入。

​ 控制反转就是反转了对象的创建方式。从我们自己创建反转给了spring

DI: Dependency Injection 依赖注入

​ 实现ioc思想需要 DI提供支持

​ 注入方式：1）set方式注入 2) 构造方法注入 3) 字段注入（不推荐）

​ 注入类型：1) 值类型注入 2）引用类型注入

AOP 面向切面的编程 （横向重复，纵向抽取）

举例：拦截器（身份校验）、过滤器（编码处理）、动态代理（事务）

spring aop实现原理

动态代理（优先）：被代理对象必须要实现接口,才能产生代理对象.如果没有接口将不能使用动态代理技术

cglib代理（没有接口）：第三方代理技术,cglib代理.可以对任何类生成代理.代理的原理是对目标对象进行继承代理. 如果目标对象被final修饰.那么该类无法被cglib代理.

spring名词解释

aop依赖所需包

aop代码演示（xml配置）

//通知类
public class MyAdvice {
	//前置通知
	//	|-目标方法运行之前调用
	//后置通知(如果出现异常不会调用)
	//	|-在目标方法运行之后调用
	//环绕通知
	//	|-在目标方法之前和之后都调用
	//异常拦截通知
	//	|-如果出现异常,就会调用
	//后置通知(无论是否出现 异常都会调用)
	//	|-在目标方法运行之后调用
	//----------------------------------------------------------------
	//前置通知
	public void before(){
		System.out.println("这是前置通知");
	}
	//后置通知
	public void afterReturning(){
		System.out.println("这是后置通知(出现异常不执行)!!");
	}
	//环绕通知
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("这是环绕通知之前的部分!");
		Object proceed = pjp.proceed();//璋冪敤鐩爣鏂规硶
		System.out.println("这是环绕通知之后的部分");
		return proceed;
	}
	//异常通知
	public void afterException(){
		System.out.println("这是异常通知，出现异常执行!");
	}
	//后置通知
	public void after(){
		System.out.println("这是后置通知(出现异常也会调用)!!");
	}
}

	<!-- 1.配置目标对象 -->
	<bean name="userService" class="com.yoci.service.UserServiceImpl"></bean>

	<!-- 2.配置通知对象 -->
	<bean name="myAdvice" class="com.yoci.springaop.MyAdvice"></bean>

	<!-- 3.配置将通知织入目标对象 -->
	<aop:config>
		<!-- 配置切入点
			public void cn.itcast.service.UserServiceImpl.save()
			void cn.itcast.service.UserServiceImpl.save()
			* cn.itcast.service.UserServiceImpl.save()
			* cn.itcast.service.UserServiceImpl.*()
			* cn.itcast.service.*ServiceImpl.*(..)
			* cn.itcast.service..*ServiceImpl.*(..)
		-->
		<aop:pointcut expression="execution(* com.yoci.service.*ServiceImpl.*(..))" id="pc"/>
		<aop:aspect ref="myAdvice">
			<!-- 指定名为before方法作为前置通知 -->
			<aop:before method="before" pointcut-ref="pc"/>
			<!-- 后置 -->
			<aop:after-returning method="afterReturning" pointcut-ref="pc" />
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="pc"/>
			<!-- 异常拦截通知 -->
			<aop:after-throwing method="afterException" pointcut-ref="pc"/>
			<!-- 后置 -->
			<aop:after method="after" pointcut-ref="pc"/>
		</aop:aspect>
	</aop:config>

aop代码演示（注解配置）

//通知类
@Aspect
public class MyAdvice {

	@Pointcut("execution(* com.yoci.service.*ServiceImpl.*(..))")
	public void pointcut(){}

	@Before("MyAdvice.pointcut()")
	public void before(){
		System.out.println("这是前置通知");
	}
	@AfterReturning("execution(* com.yoci.service.*ServiceImpl.*(..))")
	public void afterReturning(){
		System.out.println("这是后置通知(出现异常不执行)!!");
	}

	@Around("execution(* com.yoci.service.*ServiceImpl.*(..))")
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("这是环绕通知之前的部分!");
		Object proceed = pjp.proceed();//调用目标方法
		System.out.println("这是环绕通知之后的部分");
		return proceed;
	}

	@AfterThrowing("execution(* com.yoci.service.*ServiceImpl.*(..))")
	public void afterException(){
		System.out.println("这是异常通知，出现异常执行!");
	}

	@After("execution(* com.yoci.service.*ServiceImpl.*(..))")
	public void after(){
		System.out.println("这是后置通知(出现异常也会调用)!!");
	}
}

	<!-- 1.配置目标对象 -->
	<bean name="userService" class="com.yoci.service.UserServiceImpl"></bean>

	<!-- 2.配置通知对象 -->
	<bean name="myAdvice" class="com.yoci.annotationaop.MyAdvice"></bean>

	<!-- 3.开启使用注解完成织入 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

spring 中的工厂（容器）

​

​ ApplicationContext接口由两个实现类：

​ 1) ClassPathXmlApplicationContext: 加载类路径下的spring的配置

​ 2）FilesSystemXmlApplicationContext：加载本地磁盘下的spring的配置

​ BeanFactrory（过时）

​

​ BeanFactory和ApplicationContext的区别：

​ 1）BeanFactory：是在getBean的时候才会生成类的实例

​ 2）ApplicationContext：是在加载applicationContext.xml（容器启动）时就会创建

spring配置详解

Bean元素

	<!-- 将User对象交给spring容器管理 -->
	<!-- Bean元素:使用该元素描述需要spring容器管理的对象
			class属性:被管理对象的完整类名.
			name属性:给被管理的对象起个名字.获得对象时根据该名称获得对象.
					可以重复.可以使用特殊字符.
			id属性: 与name属性一模一样.
					名称不可重复.不能使用特殊字符.
			结论: 尽量使用name属性.
	  -->
	<bean  name="user" class="cn.itcast.bean.User" ></bean>

	<!-- 导入其他spring配置文件 -->
	<!-- 分模块配置 -->
	<import resource="cn/itcast/b_create/applicationContext.xml"/>

Bean元素进阶

​ scope属性（作用域）

​ 1）singleton(默认值):单例对象.被标识为单例的对象在spring容器中只会存在一个实例

​ 2）prototype:多例原型.被标识为多例的对象,每次再获得才会创建.每次创建都是新的对象.整合struts2时,ActionBean必须配置为多例的.

​ 3）request:web环境下.对象与request生命周期一致.

​ 4）session:web环境下,对象与session生命周期一致.

​ 5）global-session：global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。

​

​ 生命周期属性

​ 1）init-method：配置一个方法作为生命周期初始化方法.spring会在对象创建之后立即调用.

​ 2）destory-method：配置一个方法作为生命周期的销毁方法.spring容器在关闭并销毁所有容器中的对象之前调用.

<bean  name="user" class="cn.itcast.bean.User"
		 init-method="init" destroy-method="destory" ></bean>

public class User {
	private String name;
	private Integer age;
	private Car car;

	public Car getCar() {return car;}
	public void setCar(Car car) {this.car = car;}
	public String getName() {return name;}
	public void setName(String name) {this.name = name;}
	public Integer getAge() {return age;}
	public void setAge(Integer age) {this.age = age;}

	public void init(){
		System.out.println("我是初始化方法!");
	}
	public void destory(){
		System.out.println("我是销毁方法!");
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
	}

}

​

spring创建对象的方式

​ 1）空参构造方式

​ 2）静态工厂（了解）

​ 3）实例工厂（了解）

	<!-- 创建方式1:空参构造创建  -->
	<bean  name="user" class="cn.itcast.bean.User"
		 init-method="init" destroy-method="destory" ></bean>

	<!-- 创建方式2:静态工厂创建
		  调用UserFactory的createUser方法创建名为user2的对象.放入容器
	 -->
	<bean  name="user2"
		class="cn.itcast.b_create.UserFactory"
		factory-method="createUser" ></bean>

	<!-- 创建方式3:实例工厂创建
		 调用UserFactory对象的createUser2方法创建名为user3的对象.放入容器
	 -->
	<bean  name="user3"
		factory-bean="userFactory"
		factory-method="createUser2" ></bean>

	<bean  name="userFactory"
		class="cn.itcast.b_create.UserFactory"   ></bean>

public class UserFactory {

	public static User createUser(){

		System.out.println("静态工厂创建User");

		return new User();

	}

	public  User createUser2(){

		System.out.println("实例工厂创建User");

		return new User();

	}

}

spring属性注入

	<!-- set方式注入: -->
	<bean name="user" class="com.yoci.entity.User" >
		<!-- 值类型注入 -->
		<property name="name" value="zhangsan"></property>
		<property name="age" value="22"></property>
		<!-- 引用类型注入 -->
		<property name="car" ref="car"></property>
	</bean>

	<!-- 将car对象配置到容器当中 -->
	<bean name="car" class="com.yoci.entity.Car">
		<property name="name" value="兰博基尼"></property>
		<property name="color" value="黄色"></property>
	</bean>

	<!-- 构造函数注入 -->
	<bean name="user1" class="com.yoci.entity.User">
		<!-- name属性: 构造函数的参数名 -->
		<!-- index属性: 构造函数的参数索引 -->
		<!-- type属性: 构造函数的参数类型-->
		<constructor-arg name="name" index="0"  value="李四" ></constructor-arg>
		<constructor-arg name="car" index="1" ref="car" ></constructor-arg>
	</bean>

	<!-- p名称空间注入 -->
	<!--
		1.导入P名称空间  xmlns:p="http://www.springframework.org/schema/p"
		2.使用p:属性完成注入
		-值类型: p:属性名="值"
		-对象类型: p:属性名-ref="bean名称" -->
	<bean name="user2" class="com.yoci.entity.User" p:name="wangwu" p:age="26" p:car-ref="car"></bean>

	<!-- spEL注入 -->
	<bean name="user3" class="com.yoci.entity.User">
		<property name="name" value="#{user1.name}"></property>
		<property name="age" value="#{user2.age}"></property>
		<property name="car" ref="car"></property>
	</bean>

	<!-- 复杂类型注入 -->
	<bean name="collection" class="com.yoci.entity.Collection">
		<!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可
			<property name="arr" value="tom" ></property>
		-->
		<!-- array注入,多个元素注入 -->
		<property name="arr">
			<array>
				<value>tom</value>
				<value>jack</value>
				<ref bean="user2"></ref>
			</array>
		</property>

		<!--
			如果List中只准备注入一个值(对象),直接使用value|ref即可
			<property name="list" value="jack" ></property>
		-->
		<property name="list">
			<list>
				<value>zhangsan</value>
				<value>李四</value>
				<ref bean="user"/>
			</list>
		</property>

		<!-- map类型注入 -->
		<property name="map">
			<map>
				<entry key="url" value="www.yoci.com"></entry>
				<entry key="user3" value-ref="user"></entry>
			</map>
		</property>

		<!-- prperties 类型注入 -->
		<property name="prop">
			<props>
				<prop key="driverClass">com.jdbc.mysql.Driver</prop>
				<prop key="userName">root</prop>
				<prop key="password">1234</prop>
			</props>
		</property>

spring事务

什么是事务：

​ 事务逻辑上的一组操作，组成这组操作的各个逻辑单元，要么一起成功，要么一起失败。

事务特性

原子性 :强调事务的不可分割.

一致性 :事务的执行的前后数据的完整性保持一致.

隔离性 :一个事务执行的过程中,不应该受到其他事务的干扰

持久性 :事务一旦结束,数据就持久到数据库

如果不考虑隔离性引发安全性问题:

脏读 :一个事务读到了另一个事务的未提交的数据

不可重复读 :一个事务读到了另一个事务已经提交的 update 的数据导致多次查询结果不一致.

虚幻读 :一个事务读到了另一个事务已经提交的 insert 的数据导致多次查询结果不一致.

解决读问题:设置事务隔离级别

未提交读 :脏读，不可重复读，虚读都有可能发生

已提交读 :避免脏读。但是不可重复读和虚读有可能发生

可重复读 :避免脏读和不可重复读.但是虚幻读有可能发生.

串行化的 :避免以上所有读问题.

Mysql 默认:可重复读 Oracle 默认:读已提交

事务的操作对象

​ 在spring中玩事务管理.最为核心的对象就TransactionManager对象

事务的属性介绍

​ 事务隔离级别：

​ 1 读未提交 2 读已提交 4 可重复读 8 串行化

​ 是否只读：

​ true/false

​ 事务的传播行为：

spring代码（xml配置）

<!-- 事务管理器 -->
	<bean id="transactionManager"	class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 数据源 -->
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 通知 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>

          <!-- 以方法为单位,指定方法应用什么事务属性
			isolation:隔离级别
			propagation:传播行为
			read-only:是否只读
		 -->
          <!-- 传播行为 -->
		<tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		<tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
		<tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
		<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
		</tx:attributes>
	</tx:advice>

	<!-- 切面 -->
	<aop:config>
		<aop:advisor advice-ref="txAdvice"
			pointcut="execution(* cn.itcast.crm.service.*.*(..))" />
	</aop:config>

spring代码（注解配置）

<!-- 事务管理器 -->
	<bean id="transactionManager"	class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 数据源 -->
		<property name="dataSource" ref="dataSource" />
	</bean>

<!-- 开启使用注解管理aop事务 -->
<tx:annotation-driven/>

@Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=true)
public class AccountServiceImpl implements AccountService {

	private AccountDao ad ;
	private TransactionTemplate tt;
		@Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=false)
	public void transfer(final Integer from,final Integer to,final Double money) {
				//减钱
				ad.decreaseMoney(from, money);
				int i = 1/0;
				//加钱
				ad.increaseMoney(to, money);
	}

}

spring注解

开启spring注解

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd ">

<!--
	引入：
	xmlns:context="http://www.springframework.org/schema/context"
	http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.2.xsd
-->
<!-- 指定扫描cn.itcast.bean报下的所有类中的注解.
	 注意:扫描包时.会扫描指定报下的所有子孙包
 -->
<context:component-scan base-package="cn.itcast.bean"></context:component-scan>

</beans>

注解使用介绍

@Component("user") = <bean name="user" class="cn.itcast.bean.User"  />
  // service层
  @Service("user")
  // web层
  @Controller("user")
  // dao层
  @Repository("user")

//指定对象的作用范围
@Scope(scopeName="singleton/prototype")

//属性注入，推荐使用set方法注入方式， 第一种破坏封装性
@Value("18")
private Integer age;
@Value("tom")
public void setName(String name) {
  this.name = name;
}

//自动装配
@Autowired //问题:如果匹配多个类型一致的对象.将无法选择具体注入哪一个对象.
@Qualifier("car2")//使用@Qualifier 配合 @Autowired注解告诉spring容器自动装配哪个名称的对象
//手动装配,指定注入哪个名称的对象
@Resource(name="car")
private Car car;

//在对象被创建后调用.init-method
@PostConstruct
public void init(){
  System.out.println("我是初始化方法!");
}

//在销毁之前调用.destory-method
@PreDestroy
public void destory(){
  System.out.println("我是销毁方法!");
}

spring整合junit测试

导入aop+test包

//帮我们创建容器
@RunWith(SpringJUnit4ClassRunner.class)
//指定创建容器时使用哪个配置文件
@ContextConfiguration("classpath:applicationContext.xml")
//指定多个配置文件时
@ContextConfiguration(locations = { "classpath*:/spring1.xml", "classpath*:/spring2.xml" })
public class Demo {
	//将名为user的对象注入到u变量中
	@Resource(name="user")
	private User u;

	@Test
	public void fun1(){

		System.out.println(u);

	}

}