5.增强(xml配置方式)

一.配置文件方式

1.UserServiceImpl.java

package cn.qf.spring.service.impl;

import cn.qf.spring.dao.impl.UserDaoImpl;
import cn.qf.spring.pojo.User;
import cn.qf.spring.service.UserService;

public class UserServiceImpl implements UserService{
	//注入方式2:构造注入,通过构造方法给属性赋值
	public UserServiceImpl() {}
	public UserServiceImpl(UserDaoImpl udi) {
		this.udi = udi;
	}
	
	//注入方式1:设值注入
	private UserDaoImpl udi;
	public UserDaoImpl getUdi() {
		return udi;
	}
	public void setUdi(UserDaoImpl udi) {
		this.udi = udi;
	}
	
	//对应cn.qf.spring.dao.impl中的addUser(User user)方法
	public void addUser(User user) {
		//事物处理
		//异常处理
		//记录日志
		//只完成核心功能代码
		this.udi.addUser(user);
	}
	
}

2.AddUserServlet.java

package cn.qf.spring.controller;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.qf.spring.pojo.User;
import cn.qf.spring.service.UserService;

/**
 * Servlet implementation class AddUserServlet
 */
public class AddUserServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public AddUserServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		request.setCharacterEncoding("utf-8");
		User user = new User();
		user.setUserCode(request.getParameter("uc"));
		user.setUserName(request.getParameter("un"));
		user.setPassword(request.getParameter("up"));
		//获取UserServiceImpl类的对象
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserService us = (UserService)ac.getBean("UserService");
		us.addUser(user);
		PrintWriter pw = response.getWriter();
		pw.print("success");
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

3.前置和后置增强
OperLog.java

package cn.qf.spring.aop;

import java.util.Arrays;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;

public class OperLog {
	//记录日志的方法
	public static final Logger logger=Logger.getLogger(OperLog.class);
	
	//前置增强方法:在执行核心功能之前调用的方法
	//记录日志
	//JoinPoint 是springAOP里的对象:连接点对象
	//作用:把spring的代理对象所执行的核心方法信息都封装在此对象中:方法名,返回值,参数列表
	//jp.getTarget()  获取核心方法所在的类
	//jp.getSignature() 核心方法的名字
	//jp.getArgs() 获取核心方法的参数列表,是数组
	public void beforeLog(JoinPoint jp) {
		logger.debug("执行了"+jp.getTarget()+"类里的"+jp.getSignature()
		+"方法"+",方法的参数列表为:"+Arrays.toString(jp.getArgs()));
	}
	
	//后置增强方法:在执行核心功能之后调用的方法
	//参数1:连接点对象,封装了核心方法的信息
	//参数2:方法的执行结果,代理对象会自动传递实参给此方法
	public void afterLog(JoinPoint jp,Object result) {
		logger.debug(jp.getTarget()+"类中的"+jp.getSignature()+"方法执行结束,方法的返回值:"
				+result);
	}
}

4.==异常处理增强和最终增强
ExceptionLog.java

package cn.qf.spring.aop;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;

public class ExceptionLog {
	private static final Logger logger = Logger.getLogger(ExceptionLog.class);
	
	//异常处理增强:当核心方法发生异常后,执行的通用功能
	public void catchException(JoinPoint jp,RuntimeException ex) {
		logger.error(jp.getTarget()+"类里的"+jp.getSignature()+"方法发生异常,异常信息如下:"
				+ ex.getMessage());
	}
	
	//最终增强:当执行核心方法的finally语句块时,执行的通用功能
	public void runFinally(JoinPoint jp) {
		logger.debug(jp.getTarget()+"类里的"+jp.getSignature()+"方法执行结束");
	}
}

5.环绕增强方式(相当于以上几种增强的集合)
Arround.java

package cn.qf.spring.aop;

import java.util.Arrays;

import org.apache.log4j.Logger;
import org.aspectj.lang.ProceedingJoinPoint;

public class Arround {
	private static final Logger logger = Logger.getLogger(Arround.class);
	//环绕增强,只有一个方法就行
	public Object arroundLogger(ProceedingJoinPoint jp) {
		//声明变量存放目标方法的返回值
		Object result = null;
		//1.相当于前置增强的方法
		logger.debug("环绕增强--执行了:"+jp.getTarget()+"对象里的:"+jp.getSignature()+"方法,"
				+"方法的参数是:"+Arrays.toString(jp.getArgs()));
		//相当于异常处理增强和最终增强
		try {
			//调用目标对象的方法,proceed()是代理方法
			result = jp.proceed();
			
		}  catch (Throwable e) {
			//2.异常处理增强
			logger.error("环绕增强--执行"+jp.getSignature()+"方法发生异常:异常信息如下:"+e.getMessage());
			e.printStackTrace();
		} finally {
			//3.相当于最终增强
			logger.debug("环绕增强--执行"+jp.getSignature()+"方法结束");
		}
		//4.相当于后置增强
		logger.debug("环绕增强--执行了后置增强方法");
		return result;
	}
}

6.applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<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"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
	
	<!-- 配置UserDaoImpl类的对象 -->
	<bean id="dao" class="cn.qf.spring.dao.impl.UserDaoImpl"></bean>
	
	<!-- 配置UserServiceImpl类的对象 -->
	<bean id="UserService" class="cn.qf.spring.service.impl.UserServiceImpl">
		<!-- 1.设值注入 -->
		<!--
		<property name="udi" ref="dao"></property>
		-->
		
		<!-- 2.构造注入 -->
		<constructor-arg>
			<ref bean="dao"/>
		</constructor-arg>
	</bean>
	
	<!-- 一.配置增强方法类的对象 -->
	<bean id="theLog" class="cn.qf.spring.aop.OperLog"></bean>
	<bean id="theException" class="cn.qf.spring.aop.ExceptionLog"></bean>
	<bean id="theArround" class="cn.qf.spring.aop.Arround"></bean>
	<!-- 进行aop的配置 -->
	<aop:config>
		<!-- 二.配置切入点(执行的核心方法)
			有两种配置方式:
			1.明确核心方法的名字
			2.通过通用表达式来配置核心方法:代表一类方法
		 -->
		 <aop:pointcut expression="execution(public void addUser(cn.qf.spring.pojo.User))" 
		 			   id="addUserPoint"/>
		 		   
		 <!-- 在切面中配置增强方法   切面:所有增强方法的集合 -->
		 <aop:aspect ref="theLog">
		 	<!-- 在切面中指定哪种增强:前置,后置,异常处理,最终 -->
		 	<!-- aop:before  前置增强 -->
		 	<aop:before method="beforeLog" pointcut-ref="addUserPoint"/>
		 	<!-- aop:after-returning 后置增强 -->
		 	<aop:after-returning method="afterLog" pointcut-ref="addUserPoint" returning="result"/>
		 </aop:aspect>
		 
		 <!-- 在切面中配置异常处理增强,最终增强 -->
		 <aop:aspect ref="theException">
		 	<!-- 异常处理增强 -->
		 	<aop:after-throwing method="catchException" pointcut-ref="addUserPoint" throwing="ex"/>
		 	<!-- 最终增强 -->
		 	<aop:after method="runFinally" pointcut-ref="addUserPoint"/>
		 </aop:aspect>
		 
		 
		 <!-- 三.配置环绕增强 -->
		 <aop:aspect ref="theArround">
		 	<aop:around method="arroundLogger" pointcut-ref="addUserPoint"></aop:around>
		 </aop:aspect>
	</aop:config>
	
</beans>