Spring学习笔记

一、Spring IOC
 1.构造函数注入
(1)按类型匹配入参：
public Car(String brand,double price){
this.brand = brand;
this.price = price;
}
配置文件：
<bean id='car1' class="XXX.Car">
<constructor-arg type="java.lang.String">
<value>红旗11</value>
</constructor-arg>
<constructor-arg type="double">
<value>200000</value>
</constructor-arg>
</bean>
(2)按索引匹配入参：
<bean id='car1' class="XXX.Car">
<constructor-arg index="0" value="红旗111"/>
<constructor-arg index="1">
<value>200000</value>
</constructor-arg>
</bean>
(3)联合类型和索引匹配入参:
<bean id='car1' class="XXX.Car">
<constructor-arg index="0" type="java.lang.String" value="红旗111"/>
<constructor-arg index="1" type="double">
<value>200000</value>
</constructor-arg>
</bean>
(4)通过自身类型反射入参：
<bean id='car1' class="XXX.Car">
<constructor-arg value="红旗111"/>
<constructor-arg>
<value>200000</value>
</constructor-arg>
</bean>
 2.属性注入
<bean id="user" class="test.spring.bean.User">
<!-- 使用Set方式注入属性值 -->
<property name="userName"> --------><property name="userName" value="ZhangXiaodong" />
<value>ZhangXiaodong</value>
</property>
<property name="userPsd"> --------><property name="userPwd" value="123456" />
<value>123344</value>
</property>
</bean>
 3.接口注入(通过Factory方式注入)
public class CarFactory{
public Car createHongqiFactory(){
Car car = new Car();
car.setBrand("红旗111);
return car;
}
}
配置文件：
<bean id="carfactory" class="XXX.CarFactory"/>
<bean id="car5" factory-bean="carfactory" factory-method="createHongqiFactory"/> 


二、bean
1.bean的命名规则：必须以字母开头，后面可以是字母、数字、下划线、连接符等等。
2.bean之间的关系：
(1)继承
<bean id="abstractCar" class="XXX.Car" p:brand="红旗111" p:price="22222" p:color="红色" abstract="true"/>
<bean id="car3" p:color="黑色" parent="abstractCar"/>
<bean id="car4" p:color="白色" parent="abstractCar"/>
(2)依赖
<bean id="manager" class="XXX.CacheManager" depends-on="sysInt"/>
<bean id="sysInt" class="XXX.SysInt"/>
(3)引用
<bean id="car" class="XXX.Car"/>
<bean id="boss" class="XXX.Boss">
<property name="carId">
<idref bean="car"/>
</property>
</bean>
3.bean作用域类型
(1)singleton 在Spring IOC容器中仅存在一个Bean实例，Bean以单实例的方式存在。
(2)prototype 每次从容器中调用Bean时，都会返回一个新的实例，即每次调用getBean()时，相当于执行newXXXBean的操作。
(3)request 每次Http请求都会创建一个新的Bean。该作用仅适用于WebApplicationContext.xml环境下。
(4)session 同一个HttpSession共享一个Bean，不同HttpSession适用不同的Bean，该作用仅适用于WebApplicationContext.xml环境下。
(5)globalSession 同一个全局Session共享一个Bean，一般用于Porlet应用环境。该作用仅适用于WebApplicationContext.xml环境下。
4.基于XML装配bean
bean、constract-arg、property、ref、value、list、set、map、entry、props、prop、null。
标签使用特例如下：
<!-- 通过构造方法注入属性值装配SimpleDateFormat单实例 -->
<bean id="simpleDateFormat" class="java.text.SimpleDateFormat">
<!-- 在注入构造参数时,如果只有一个字符串类型的参数,则可省略index与type属性 -->
<constructor-arg value="yyyy年MM月dd hh时mm分ss秒" />
</bean>


<!-- 使用原型模式装配User实例 -->
<bean id="user" class="test.spring.bean.User" scope="prototype">
<!-- 使用Set方式注入属性值 -->
<property name="userName" value="ZhangXiaodong" />
<property name="userPwd" value="123456" />
</bean>

<!-- 使用单例模式装配XmlIocBean实例,同时指定初始化方法与销毁方法 -->
<bean id="xmlIocBean" class="test.spring.bean.XmlIocBean" init-method="myInit" destroy-method="myDestroy">
<!-- 使用构造方式注入属性值 -->
<constructor-arg index="0" type="java.text.SimpleDateFormat" ref="simpleDateFormat"/>
<constructor-arg index="1" type="java.util.Date">
<!-- 定义内部Bean实例 -->
<bean class="java.util.Date"/>
</constructor-arg>
<!-- 使用Set方式注入数组类型属性 -->
<property name="intnumber">
<list>
<value>2</value>
<value>15</value>
<value>7</value>
</list>
</property>
<!-- 使用Set方式注入List类型属性 -->
<property name="list">
<list>
<value>元素1</value>
<!-- 由于上面的User实例使用原型模式装配,每次引用的将是全新的User实例 -->
<ref bean="user"/>
<ref bean="user"/>
</list>
</property>
<!-- 使用Set方式注入Set类型属性 -->
<property name="set">
<set>
<value>set元素1</value>
<value>set元素2</value>
</set>
</property>
<!-- 使用Set方式注入Map类型属性 -->
<property name="map">
<map>
<entry key="key1">
<value>map元素1</value>
</entry>
<entry key="key2">
<ref bean="user"/>
</entry>
</map>
</property>
<!-- 使用Set方式注入Properties类型属性 -->
<property name="props">
<props>
<prop key="prop1">properties元素1</prop>
<prop key="prop2">properties元素2</prop>
</props>
</property>
</bean>
5.基于Annotation装配Bean
(1)@Autowired 默认按照bean类型装配，如果匹配不到则抛出异常。(不推荐使用)
(2)@Resource 默认按照bean的名称装配，匹配不到再按照bean类型匹配，再找不到则抛出异常。(经常使用)
(3)@Qualifier =@Autowired+@Resource注解，可以将默认按Bean类型装配变换成按照Bean名称装配。(我个人感觉也不经常使用)
(4)@PostConstract 在Bean的某个方法上加上@PostConstract注解，则该方法会在Bean初始化后被Spring容器调用，作用等同于在Spring配置
文件中为bean标签指定的init-method属性。
(5)@PreDestory 在Bean的某个方法上加上@PreDestory注解，则该方法会在Bean销毁之前被Spring容器调用，作用等同于在Spring配置
文件中为bean标签指定的destory-method属性。
6.基于Annotation装配Bean步骤
(1)在Spring配置文件中引入相应的SchemaLocation
(2)开启相应的注解处理器：<context:annotation-config/>
(3)在Class类相应位置加上面所讲的注解。


三、Spring AOP
1.AOP常用术语
(1)切面(Aspect):切面其实就是共有功能的实现。如：日志切面、权限切面、事务切面等。在实际中切面经常是指带有公共功能的Java类。
之所以能被AOP识别为切面，是在配置文件中配置好了。
(2)通知(Advice):通知是具体切面的实现，以目标方法为参照点，根据放置的位置可分为：前置通知、后置通知、异常通知、最后通知、环绕通知。
在实际应用中通常是切面类中的一个方法。
(3)连接点(Joinpoint):连接点就是程序运行过程中能够插入切面的地方。
(4)切入点(Pointcut):切入点用于定义通知应该切入到哪些连接点上。
(5)目标对象(Target):目标对象就是那些将切入切面的对象，也就是那些被通知的对象。
(6)代理对象(Proxy):代理对象是将通知应用到目标对象之后被动态创建的对象。
(7)织入(Weaving):织入是将切面应用到目标对象从而创建一个新的代理对象的过程。
2.基于XML方式的AOP实现
<!-- 注册一个UserAction实例名称为userAction -->
<bean id="userAction" class="test.spring.action.UserAction">
<!-- 将UserServiceImpl实例service注入给UserAction实例的service属性 -->
<property name="service" ref="service" />
</bean>
<!-- 将日志切面交给Spring容器管理 -->
<bean id="logAspectJ" class="test.spring.aop.LogAspectJ"/>
<!-- 使用XML方式进行AOP配置 -->
<aop:config>
 <!-- 使用XML方式配置日志切面 -->
 <aop:aspect id="logaop" ref="logAspectJ">
<!-- 定义切入点，切入点正则表达式execution(* test.spring.action.UserAction.*(..))
的意思是拦截test.spring.action.UserAction类中的所有方法,不论方法参数有无,
也不管返回结果为何类型。
-->
<aop:pointcut id="logpointcut" expression="execution(* test.spring.action.UserAction.*(..))"/>
<!-- 将LogAspectJ切面中的myBeforeAdvice方法定义成前置通知 -->
<aop:before pointcut-ref="logpointcut" method="myBeforeAdvice"/>
<!-- 将LogAspectJ切面中的myAfterReturningAdvice方法定义成后置通知 -->
<aop:after-returning pointcut-ref="logpointcut" method="myAfterReturningAdvice"/>
<!-- 将LogAspectJ切面中的myAfterThrowingAdvice方法定义成异常通知 -->
<aop:after-throwing pointcut-ref="logpointcut" method="myAfterThrowingAdvice" throwing="e"/>
<!-- 将LogAspectJ切面中的myAfterAdvice方法定义成最终通知 -->
<aop:after pointcut-ref="logpointcut" method="myAfterAdvice"/>
<!-- 将LogAspectJ切面中的myAroundAdvice方法定义成环绕通知 -->
<aop:around pointcut-ref="logpointcut" method="myAroundAdvice"/>
 </aop:aspect>
</aop:config>
3.基于Annotation方式的AOP实现
(1)@Aspect():用于定义一个切面
(2)@Pointcut():用于定义一个切入点，该注解比较奇怪，切入点的名称是由一个方法名称定义的。如：
@Pointcut()
private void anyMethod(){}//定义切入点的名字
(3)@Before():用于定义前置通知，使用该注解时必须提供一个切入点名称参数，例：
@Before("anyMethod()")
(4)@AfterReturning():用于定义后置通知，使用该注解时必须提供一个切入点名称参数，例：
@AfterReturning("anyMethod()")
(5)@AfterThrowing():用于定义异常通知，使用该注解时必须提供一个切入点名称参数，例：
@AfterThrowing("anyMethod()")
(6)@After():用于定义最后通知，使用该注解时必须提供一个切入点名称参数，例：
@After("anyMethod()")
(7)@Around():用于定义环绕通知，使用该注解时必须提供一个切入点名称参数，例：
@Around("anyMethod()")
四、Spring DAO
1.Spring为不同持久化技术提供了模板
ORM持久化技术 模板类
JDBC org.springframework.jdbc.core.JdbcTemplate
Hibernate3.0 org.springframework.orm.hibernate3.HibernateTemplate
iBatis org.springframework.orm.ibatis.SqlMapClientTemplate
JPA org.springframework.jpa.JpaTemplate
JDO org.springframework.orm.jdo.JdoTemplate
TopLink org.springframework.orm.jpa.JpaTemplate

模板应用步骤：
(1)首先，在applicationContext.xml中配置dataSource数据源。
(2)然后，在applicationContext.xml装配JdbcTemplate模板的bean类，将dataSource作为参数注入。
(3)这样就可以在DAO层获取模板类来操作数据库，可以使用Annotation自动注入模板，也可以通过XML注入模板类。
<!-- 注册一个JdbcTemplate实例名称为jdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg ref="dataSource"/>
</bean>  
2.Spring数据源的实现
Spring在第三方依赖包中包含了两个数据源的实现类包：一个是Apache的DBCP;一个是C3P0.
(1)DBCP数据源：
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"
p:driverClassName="com.mysql.jdbc.Driver"
p:url="jdbc:mysql://localhost:3309/sampledb"
p:username="root"
p:password="1234"/>
(2)C3P0数据源
<bean id="dataSource"
class="org.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"
p:driverClass="com.jdbc.driver.OracleDriver"
p:jdbcUrl="jdbc:oraclethin:@localhost:1521:ora11g"
p:user="admin"
p:password="1234"/>


五、Spring transaction management
1.事务的特性
(1)原子性
(2)一致性
(3)隔离性
(4)持久性
2.事务的传播行为
PROPAGATION_MANDATORY 规定了方法必须在事务中运行，否则抛出异常。
PROPAGATION_NESTED 使方法运行在嵌套事务中，否则这个属性和PROPAGATION_REQUIRED属性的含义相同。
PROPAGATION_NEVER 使当前方法永远不在事务中运行，否则抛出异常。
PROPAGATION_NOT_SUPPORTED 定义当前事务不支持的方法，在该方法运行期间正在运行的事务会被暂停。
PROPAGATION_REQUIRED 规定当前的方法必须在事务中，如果没有事务则创建一个新事务，一个新事务和方法一同开始，
随着方法的返回或抛出异常而终止。
PROPAGATION_REQUIRED_NEW 当前方法必须必须创建新事务来运行，如果现存的事务正在运行就暂停它。
PROPAGATION_SUPPORTS 规定当前方法支持事务处理，但如果没有事务运行就使用非事务方法执行。
以上定义Spring在事务传播行为分别对应EJB的事务CMT中的所有传播行为，其中PROPAGATION_NESTED是Spring在CMT之外定义的事务传播行为。
3.Spring事务管理：
(1)编程式事务管理
(2)声明式事务管理
4.Spring3.X声明式事务管理-事务属性(对应上面事务传播行为)
MANDATORY 
NESTED
NEVER  
NOT_SUPPORTED  
REQUIRED  
REQUIRESNEW
SUPPORTS  
5.基于XML方式的事务管理配置
(1)在Spring配置文件中配置事务之前，先要将事务管理标签所需要的命名空间导入，例如：
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" 
xmlns:tx="http://www.springframework.org/schema/tx" //事务管理标签命名空间
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">
(2)基于XML方式的事务管理配置
<!-- 注册一个JDBC数据源事务管理器 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>
<!-- 基于AOP技术的事务管理实现 -->
<aop:config>
<!-- 定义一个事务切入点,拦截test.spring.dao.impl.UserDaoImpl中的所有方法 -->
<aop:pointcut id="transactionPointcut" expression="execution(* test.spring.dao.impl.UserDaoImpl.*(..))"/>
<!-- 引用txAdvice事务通知 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>
<!-- 定义一个事务通知txAdvice -->
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<!-- 所有以load开头的方法声明为不需要事务 -->
<tx:method name="load*" read-only="true" propagation="NOT_SUPPORTED"/>
<!-- 其它所有方法声明为默认的REQUIRED类型的事务传播方式 -->
<tx:method name="*"/>
</tx:attributes>
</tx:advice> 
6.基于Annotation方式的事务管理配置
(1)Spring3.X为事务管理提供了@Transactional注解，通过@Transactional指定不同的参数，以满足不同的事务管理需求。
参数名称 功能描述
readOnly 该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示为可读写，默认为false.
例：@Transactional(readOnly=true)
rollbackFor 该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常类数组中的异常时，则进行事务回滚。
例：指定单一异常类：@Transactional(rollbackFor=RuntimeException.class)
指定多个异常类：@Transactional(rollbackFor={RuntimeException.class,Exception.class})
rollbackForClassName 该属性用于设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，则进行事务回滚。
例：指定单一异常类名称：@Transactional(rollbackForClassName="RuntimeException")
指定多个异常类名称：@Transactional(rollbackForClassName={"RuntimeException","Exception"})
noRollbackFor 该属性用于设置不需要进行回滚的异常类数组，当方法中抛出指定异常类数组中的异常时，不进行事务回滚。
例：指定单一异常类：@Transactional(noRollbackFor=RuntimeException.class)
指定多个异常类：@Transactional(noRollbackFor={RuntimeException.class,Exception.class})
noRollbackForClassName 该属性用于设置不需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，不进行事务回滚。
例：指定单一异常类名称：@Transactional(noRollbackForClassName="RuntimeException")
指定多个异常类名称：@Transactional(noRollbackForClassName={"RuntimeException","Exception"})
propagation 该属性用于设置事务的传播行为。例：@Transactional(propagation=Propagation.NOT_SUPPORT,readOnly=true)
isolation 该属性用于设置事务的隔离级别，基本上不需要进行设置。
timeout 该属性用于设置事务超时秒数，默认值为-1表示永不超时。
(2)基于Annnotaion方式的事务管理配置
(1)在Spring配置文件中配置事务管理之前，先要将事务管理标签所需的命名空间导入。跟基于XML方式的事务管理配置一样。
(2)第二步，
<!-- 注册一个JDBC数据源事务管理器 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>  
<!-- 基于@Transactional注解方式的事务管理 -->
<tx:annotation-driven transaction-manager="txManager"/> 
<!-- 注册一个JdbcTemplate实例名称为jdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg ref="dataSource"/>
</bean>   
(3)在需要进行事务管理的方法上面使用@Transactional注解进行事务管理的声明。
@Transactional()
public void delUser(Integer id){
//删除用户逻辑代码
}