简单拦截器(spring aop)

1.applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans http://www.springframework.org/schema/beans">http://www.springframework.org/schema/beans"
xmlns:http://www.w3.org/2001/XMLSchema-instance">http://www.w3.org/2001/XMLSchema-instance"
xmlns:http://www.springframework.org/schema/p">http://www.springframework.org/schema/p"
xmlns:http://www.springframework.org/schema/aop">http://www.springframework.org/schema/aop"
xmlns:http://www.springframework.org/schema/tx">http://www.springframework.org/schema/tx"
xsi:schemaLhttp://www.springframework.org/schema/beans">http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<!--第一种配置数据源
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/beian"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
-->
<!-- 第二种方式配置数据源 -->
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
p:location="/WEB-INF/jdbc.properties" />
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource"
p:driverClassName="${jdbc.driverClassName}"
p:url="${jdbc.url}"
p:username="${jdbc.username}"
p:password="${jdbc.password}" />
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 将数据库源导入到会话工厂的class类中去 -->
<property name="dataSource">
<ref bean="dataSource"/>
</property>
<property name="hibernateProperties">
<props>
<!-- 配置hibernate方言(mysql/orcle/sqlserver)-->
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
</props>
</property>
<property name="mappingResources">
<list>
<!-- 导入hibernate 中实体JavaBean 对应的配置文件 -->
<value>com/edong/beian/model/Log.hbm.xml</value>
</list>
</property>
</bean>
<!-- 创建事务管理器 -->
<!-- jdbc,ibtas 方式
<bean id="jdbcTransaction"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
-->
<!-- hibernate 方式 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!--配置了事务拦截器-->
<bean id="interceptorTrans" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!--根据需要进行事务切换-->
<property name="transactionManager" ref="transactionManager" />
<property name="transactionAttributes">
<props>
<!--PROPAGATION_REQUIRED:
表示在当前运行的方法中:
如果没有事务环境,则添加:conn.setCommitAuto(false),且事务类型为:wr;
如果有事务环境,则把该事务类型改为:wr
-->
<!-- ServiceException 前面的符号的含义:
+ 表示在当前运行的方法中,如果抛出该类型的异常,则强制提交事务,commmit();
_ 表示在当前运行的方法中,如果抛出该类型的异常,则回退事务,以前提交的数据rollback();
-->
<!-- 为以h开头的方法进行添加事务处理为以h开头的方法进行添加事务处理 -->
<prop key="p*">
PROPAGATION_REQUIRED,-RuntimeException
</prop>
</props>
</property>
</bean>
<!-- 配置DAO-->
<bean id="logDAO" class="com.edong.beian.dao.LogDAO"/>
<!-- 配置需要被代理的目标类 -->
<bean id="logService" abstract="false"
lazy-init="default" autowire="default" dependency-check="default"
class="com.edong.beian.service.LogService">
<!--在LogService 中注入LogDAO-->
<property name="logDAO" ref="logDAO"/>
</bean>
<!--配置事务代理类-->
<bean id="transactionProxy" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<!--要对目标类DeptDAO进行自动事务处理，当调用该目标类中的方法??会给自动维护它的事务的统一性质-->
<value>logService</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>interceptorTrans</value>
</list>
</property>
<property name="optimize" value="true"/>
</bean>
<!-- 前置增强 -->
<bean id="before" class="com.edong.beian.cglib.LogMethodBeforeAdvice"/>
<!-- 后置增强 -->
<bean id="after" class="com.edong.beian.cglib.LogAfterReturningAdvice"/>
<!-- 前后增强 -->
<bean id="around" class="com.edong.beian.cglib.LogMethodInterceptor"/>
<!-- 异常增强-->
<bean id="throw" class="com.edong.beian.cglib.ThrowExceptionAdvice"/>
<!-- 返回代理对象 -->
<bean id="proxy1" class="org.springframework.aop.framework.ProxyFactoryBean">
<!--指定目标类-->
<property name="target" ref="logService"/>
<property name="proxyTargetClass" value="true"/>
<!-- 前提: 不管用hibernate的HibernateTransactionManager事务管理类
还是用 jdbc,ibatis的DataSourceTransactionManager事务管理类来进行事务管理
1. 如果目标类实现了一个接口
1) 当 optimize=true 为cglib产生的事务代理对象
2) 当 optimize=false 或 默认时 则以为jdk产生动态代理对象
2.如果目标类不实现任何接口
1) 当 optimize=true 为cglib产生的事务代理对象
2) 当 optimize=false 或默认时 则以为jdk产生动态代理对象,但是会报异常
(原因是:由jdk产生的代理时目标类必须实现一个接口,而cglib既能代理接口也能代理类)
注意:
传入 Session 注入SessionFactory 要分清
1.如果以spring内置代理(包括事务代理)时, getHibernateTemplate()
方式获取的SessionFactory 永远为空.(原因她由spring内部通过new 创
建一全新的HibernateTemplate 实列, 并不是通过获取配置文件中注入的
SessionFactory)
2.如果在配置文件中配置自动管理目标类的事务机制时,该机制只能管理通过
getHibernateTemplate()获取对象中的事务和它的统一性. 不能管理
传入的Session 的事务和它的统一性.传入的Session的事务必须手动
开启和提交.
-->
<!--添加增强类-->
<property name="interceptorNames">
<list>
<value>before</value>
<value>after</value>
<value>around</value>
<value>throw</value>
</list>
</property>
</bean>
</beans>

2. cglib:实现前增强,后增强,前后增强,异常增强 (四个单独的类)
前增强
import com.edong.ws.security.Login;
import java.lang.reflect.Method;
import java.util.Date;
import org.springframework.aop.MethodBeforeAdvice;
public class LogMethodBeforeAdvice implements MethodBeforeAdvice {
public void before(Method method, Object[] aobj, Object obj)
throws Throwable {
String date = (new Date()).toString();
Login login=null;
if(aobj.length>0){
if(aobj[0] instanceof Login){
login =(Login)aobj[0];
System.out.println("信息：[" + date + "]用户 " +login.getUsername() + " 正在尝试登录陆系统...");
}
}
}
后增强...
import com.edong.ws.security.Login;
import java.lang.reflect.Method;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.aop.AfterReturningAdvice;
public class LogAfterReturningAdvice implements AfterReturningAdvice {
public void afterReturning(Object obj, Method method, Object[] aobj,
Object obj1) throws Throwable {
String date = (new Date()).toString();
/ /防止其他方法进入:logService.getCount();方法中就没参数...所以不存在访问数组元素...就会报错..
if(aobj.length>0){
if(aobj[0] instanceof Login){
Login login=(Login)aobj[0];
System.out.println("信息：["+date+"]用户 "+login.getUsername()+" 成功登录系统.");
}
}
}
前后增强
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class LogMethodInterceptor implements MethodInterceptor {
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
Object result = null;
Object[] args = methodInvocation.getArguments();//获取传入目标方法的参数列表
int length =args.length;
for (int i = 0; i <length; i++) {
if (args instanceof Session){//判断参数类型是否是 Session
Transaction trans=((Session)(args)).beginTransaction();
try {
trans.begin();
result = methodInvocation.proceed();//调用代理目标类的具体方法
trans.commit();
} catch (Exception e) {
trans.rollback();
e.printStackTrace();
}
}
}
return result;
}
}

异常增强 :导包
import java.lang.reflect.Method;
import org.springframework.aop.ThrowsAdvice;
public class ThrowExceptionAdvice implements ThrowsAdvice {
public void afterThrowing(Method method, Object[] args, Object target,Exception ex)throws Throwable {
System.out.println("用户登录过程中发生异常: "+target.getClass().getSimpleName());
}
}


测试类：导包
import com.edong.beian.service.LogService;
import com.edong.ws.security.Login;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test{
public static void main(String[] args){
ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");//xml文件 放在src目录下
LogService logService = (LogService) ac.getBean("proxy1");
Login login=new Login();
login.setUsername("thh");
login.setPassword("aaa");
logService.clientLogin(login);
}
}