6.AOP+IoC/DI(注解方式)---简单

一.注解:

1.Dao接口的实现类:
@Repository("userDao") 让Spring创建一个名字叫“userDao”的UserDaoImpl实例

2.Service接口的实现类
@Service("userService") 让Spring创建一个名字叫“userService”的UserServiceImpl实例

3.AddUserServlet.java

4.aop层.

配置环绕增强
@Aspect 声明当前类是一个切面
@Around("execution(* cn..*.*(..))") 声明环绕增强
ProceedingJoinPoint：用于环绕通知，使用proceed()方法来执行目标方法：

4.1前置和后置增强

@Before("execution(* cn..*.*(..))") 前置增强
@AfterReturning("execution(* cn..*.*(..))") 后置增强

4.2异常处理和最终增强
@AfterThrowing("execution(* cn..*.*(..))") 异常处理增强
@After("execution(* cn..*.*(..))") 最终增强

二.使用IoC创建Bean和创建增强(注解方式)

需要的包:

---

注意:POJO实体类要实现Serializable可序列化接口

1.UserDao.java

package cn.qf.spring.dao;
import cn.qf.spring.pojo.User;

public interface UserDao {
	public int addUser(User user);
}

2.UserDaoImpl.java

package cn.qf.spring.dao.impl;

import org.springframework.stereotype.Repository;
import cn.qf.spring.dao.UserDao;
import cn.qf.spring.pojo.User;

//使用注解的方式使用IoC创建Bean
//注解一定紧挨类
//@Repositor 用来创建dao中类的对象
@Repository("userDao")
public class UserDaoImpl implements UserDao{
	
	public int addUser(User user) {
		System.out.println("保存用户数据到数据库中");
		return 0;
	}
	
}

3.UserService.java

package cn.qf.spring.service;

import cn.qf.spring.pojo.User;

public interface UserService {
	public boolean addUser(User user);
}

4.UserServiceImpl.java(自动装配)

package cn.qf.spring.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import cn.qf.spring.dao.UserDao;
import cn.qf.spring.pojo.User;
import cn.qf.spring.service.UserService;

//@Service 只能用在service层中
@Service("userService")
public class UserServiceImpl implements UserService{
	//声明UserDao类型的属性
	//为dao属性注入值
	//@Resource 是jdk内的注解,到Bean工厂中找名字是userDao的Bean,赋值给dao属性
	//@Resource(name="userDao")
	//@Autowired 是spring内的注解,根据属性的类型查找对应的Bean,找到后进行赋值
	
	@Autowired
	private UserDao dao;
	
	public boolean addUser(User user) {
		int ret = dao.addUser(user);
		if (ret==1) {
			return true;
		}else {
			return false;
		}
	}

}

5.aop层
5.1.前置和后置增强

package cn.qf.spring.aop;

import java.util.Arrays;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

//使用注解声明当前类是一个切面
@Aspect
public class OperLog {
	//获取log4j对象
	private static final Logger logger = Logger.getLogger(OperLog.class);
	
	//先配置切入点pointcut
	@Pointcut("execution(* cn..*.*(..))")
	public void pointCut() {}; //相当于切入点的Id
	
	//前置增强
	@Before("pointCut()")
	public void beforeLog(JoinPoint jp) {
		logger.debug("执行了"+jp.getTarget()+"对象,创建了"+jp.getSignature()
		+"方法,方法的参数列表是:"+Arrays.toString(jp.getArgs()));
	}
	//后置增强
	@AfterReturning("pointCut()")
	public void afterLog(JoinPoint jp,Object result) {
		logger.debug(jp.getSignature()+"方法执行结束,返回值为:"+result);
	}
}

5.2.异常处理和最终增强

package cn.qf.spring.aop;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;

//使用注解声明当前类是一个切面
@Aspect
public class ExceptionLog {
	private static final Logger logger = Logger.getLogger(ExceptionLog.class);
	
	//配置切入点,在设置增强方法过程中配置
	//异常处理增强
	@AfterThrowing(pointcut = "execution(* cn..*.*(..))")
	public void afterException(JoinPoint jp,RuntimeException ex) {
		logger.error(jp.getTarget()+"对象里的"+jp.getSignature()+"方法发生异常,异常信息如下:"
					+ex.getMessage());
	}
	
	//最终增强
	@After("execution(* cn..*.*(..))")
	public void runFinally(JoinPoint jp) {
		logger.debug(jp.getSignature()+"执行结束");
	}
	
}

5.3.环绕增强

package cn.qf.spring.aop;

import org.apache.log4j.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

//使用注解声明当前类是一个切面
@Aspect
public class Arround {
	private static final Logger logger = Logger.getLogger(Arround.class);
	//声明环绕增强
	@Around("execution(* cn..*.*(..))")
	public Object aroundLog(ProceedingJoinPoint jp) {
		Object result = null;
		//前置增强
		logger.debug("执行了"+jp.getTarget()+"对象里的"+jp.getSignature()+"方法");
		
		try {
			result = jp.proceed();
		} catch (Throwable e) {
			//异常处理增强
			logger.error(jp.getSignature()+"方法发生异常:"+e.getMessage());
		} finally {
			logger.debug(jp.getSignature()+"方法执行结束");
		}
		//后置增强
		logger.debug(jp.getSignature()+"的执行结果是:"+result);
		return result;
	}
}

6.controller层
AddUserServlet.java

7.配置文件

<?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">
	
	<!-- 告知spring 扫描指定的包 -->
	<context:component-scan base-package="cn.qf.spring.service,cn.qf.spring.dao"></context:component-scan>
	<bean class="cn.qf.spring.aop.Arround"></bean>
	<!-- 启用springAop的注解方式 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>