1、AOP中的概念

Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.
joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)
Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义.
Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知
Target(目标对象):代理的目标对象
Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.
Introduction(引入):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field

Spring提供了两种切面声明方式,实际工作中我们可以选用其中一种:
基于XML配置方式声明切面。
基于注解方式声明切面

基于注解方式声明切面

首先启动对@AspectJ注解的支持:

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<aop:aspectj-autoproxy/>
<bean id="orderservice" class="cn.itcast.service.OrderServiceBean"/>
<bean id="log" class="cn.itcast.service.LogPrint"/>
</beans>


@Aspect
public class LogPrint{
	
	@Pointcut("execution(* cn.itcast.service..*.*(..))")
	private void anyMethod() {}//声明一个切入点 
	
	@Before("anyMethod()&& args(userName)")//定义前置通知
	publicvoid doAccessCheck(StringuserName) {
	} 
	
	@AfterReturning(pointcut="anyMethod()",returning="revalue")//定义后置通知
	publicvoid doReturnCheck(Stringrevalue) {
	}
	
	@AfterThrowing(pointcut="anyMethod()",throwing="ex")//定义例外通知
	publicvoid doExceptionAction(Exceptionex) {
	}
	
	@After("anyMethod()")//定义最终通知
	publicvoid doReleaseAction(){
	}
	
	@Around("anyMethod()")//环绕通知
	publicObject doBasicProfiling(ProceedingJoinPointpjp)throws Throwable {
		return pjp.proceed();
	}
}

基于XML配置方式声明切面

<bean id="orderservice" class="cn.itcast.service.OrderServiceBean"/>
<bean id="log" class="cn.itcast.service.LogPrint"/>
<aop:config>
  <aop:aspect id="myaop" ref="log">
  <aop:pointcut id="mycut" expression="execution(* cn.itcast.service..*.*(..))"/>
  <aop:before pointcut-ref="mycut" method="doAccessCheck"/>
  <aop:after-returning pointcut-ref="mycut" method="doReturnCheck "/>
  <aop:after-throwing pointcut-ref="mycut" method="doExceptionAction"/>
  <aop:after pointcut-ref="mycut" method=“doReleaseAction"/>
  <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>
  </aop:aspect>
</aop:config>

2、spring+jdbc

数据源配置:

 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
     .....略
  </bean>
  
  使用<context:property-placeholder location=“jdbc.properties”/>属性占位符
  
  <context:property-placeholder location=“jdbc.properties”/>   
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
   <property name="driverClassName" value="${driverClassName}"/>  
    <property name="url" value="${url}"/>  
    <property name="username" value="${username}"/>  
    <property name="password" value="${password}"/>  
     <!-- 连接池启动时的初始值 -->  
    <property name="initialSize" value="${initialSize}"/>  
    <!-- 连接池的最大值 -->  
    <property name="maxActive" value="${maxActive}"/>  
    <!-- 最大空闲值.当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接慢慢释放一部分,一直减少到maxIdle为止 -->  
    <property name="maxIdle" value="${maxIdle}"/>  
    <!--  最小空闲值.当空闲的连接数少于阀值时,连接池就会预申请去一些连接,以免洪峰来时来不及申请 -->  
    <property name="minIdle" value="${minIdle}"/>  
  </bean>

事务的配置方式有两种:注解方式和基于XML配置方式(引入用于声明事务的tx命名空间

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
  </bean>
 <!– 采用@Transactional注解方式使用事务  -->
  <tx:annotation-driven transaction-manager="txManager"/>
  
  @Service @Transactional
    public class PersonServiceBean implements PersonService {
}

采用基于XML方式配置事务
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>
<aop:config>
  <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
  <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config> 
<tx:advice id="txAdvice" transaction-manager="txManager">
 <tx:attributes>
   <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
   <tx:method name="*"/>
 </tx:attributes>
</tx:advice>

使用JdbcTemplate进行insert/update/delete操作
@Service @Transactional
public class PersonServiceBean implements PersonService {
	private JdbcTemplate jdbcTemplate;
	@Resource
	public void setDataSource(DataSource dataSource) {
		this.jdbcTemplate = new JdbcTemplate(dataSource);
	}
	//添加
	public void save(Person person) throws Exception{
		jdbcTemplate.update("insert into person (name) values(?)", 
				new Object[]{person.getName()}, new int[]{java.sql.Types.VARCHAR});
	}
}

获取记录:
@Service @Transactional
public class PersonServiceBean implements PersonService {
	private JdbcTemplate jdbcTemplate;
	@Resource
	public void setDataSource(DataSource dataSource) {
		this.jdbcTemplate = new JdbcTemplate(dataSource);
	}
	public Person getPerson(Integer id){
		RowMapper rowMapper = new RowMapper(){
			public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
				Person person = new Person();
				person.setId(rs.getInt("id"));
				person.setName(rs.getString("name"));
				return person;
			}
		};
		return (Person)jdbcTemplate.queryForObject("select * from person where id=?", 
				new Object[]{id}, new int[]{java.sql.Types.INTEGER}, rowMapper);
	}
}

获取多条记录:
@Service @Transactional
public class PersonServiceBean implements PersonService {
	private JdbcTemplate jdbcTemplate;
	@Resource
	public void setDataSource(DataSource dataSource) {
		this.jdbcTemplate = new JdbcTemplate(dataSource);
	}
	public List<Person> getPersons(){
		RowMapper rowMapper = new RowMapper(){
			public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
				Person person = new Person();
				person.setId(rs.getInt("id"));
				person.setName(rs.getString("name"));
				return person;
			}
		};
		return jdbcTemplate.query("select * from person", rowMapper);
	}
}

3、事务传播

事务传播属性

REQUIRED:业务方法需要在一个事务中运行。如果方法运行时,已经处在一个事务中,那么加入到该事务,否则为自己创建一个新的事务。
NOT_SUPPORTED:声明方法不需要事务。如果方法没有关联到一个事务,容器不会为它开启事务。如果方法在一个事务中被调用,该事务会被挂起,在方法调用结束后,原先的事务便会恢复执行。
REQUIRESNEW:属性表明不管是否存在事务,业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中,则原有事务会被挂起,新的事务会被创建,直到方法执行结束,新事务才算结束,原先的事务才会恢复执行。
MANDATORY:该属性指定业务方法只能在一个已经存在的事务中执行,业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用,容器就会抛出例外。
SUPPORTS:这一事务属性表明,如果业务方法在某个事务范围内被调用,则方法成为该事务的一部分。如果业务方法在事务范围外被调用,则方法在没有事务的环境下执行。
Never:指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行,容器会抛出例外,只有业务方法没有关联到任何事务,才能正常执行。
NESTED:如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.它使用了一个单独的事务, 这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效

Connection conn = null;
try {
	conn.setAutoCommit(false);
	Statement stmt = conn.createStatement();
	stmt.executeUpdate("update person set name='888' where id=1");
	Savepoint savepoint = conn.setSavepoint();
	try{   
		conn.createStatement().executeUpdate("update person set name='222' where sid=2");
	}catch(Exception ex){
		conn.rollback(savepoint);    
	}
	stmt.executeUpdate("delete from person where id=9");
	conn.commit();
	stmt.close();
} catch (Exception e) {
	conn.rollback();
}finally{
	try {
		if(null!=conn && !conn.isClosed()) conn.close();
	} catch (SQLException e) { e.printStackTrace(); }
}
}

4、数据库事务

数据库系统提供了四种事务隔离级别供用户选择。不同的隔离级别采用不同的锁类型来实现,在四种隔离级别中,Serializable的隔离级别最高,Read Uncommited的隔离级别最低。大多数据库默认的隔离级别为Read Commited,如SqlServer,当然也有少部分数据库默认的隔离级别为Repeatable Read ,如MySQL
Read Uncommited:读未提交数据(会出现脏读,不可重复读和幻读)。
Read Commited:读已提交数据(会出现不可重复读和幻读)
Repeatable Read:可重复读(会出现幻读)
Serializable:串行化