`
taody
  • 浏览: 100112 次
  • 性别: Icon_minigender_2
  • 来自: 北京
社区版块
存档分类
最新评论

Spring框架学习笔记3：AOP示例-异常日志和操作日志的记录

aopjavaspring框架jdbc 
阅读更多

AOP示例

　　1)异常日志的记录 (异常通知类型)
　　2)操作日志的记录 (环绕通知类型)
　　　　—-思考选用哪种类型的通知—-
　　　　—-思考切入点表达式的写法—-

引入spring框架包jar包：
commons-logging.jar
spring.jar
aspectjrt.jar
aspectjweaver.jar
cglib-nodep-2.1_3.jar

工具类：

FileUtil.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package com.weishuzhai.util;
 
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
 
public class FileUtil {
	/**
	 * 写文件操作
	 * 
	 * @param filePath
	 *            文件路径及其名字
	 * @param append
	 *            true追加,false覆盖
	 * @param msg
	 *            消息
	 * @throws IOException
	 */
	public static void write(String filePath, boolean append, String msg)
			throws IOException {
		FileWriter out = new FileWriter(filePath, append);
		PrintWriter pw = new PrintWriter(out);
		pw.println(msg);
		pw.close();
	}
}

PropertiesUtil.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package com.weishuzhai.util;
 
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
 
/**
 * 读取配置文件的一个工具类 提供访问.properties文件的相关方法
 * 
 * @author Administrator
 * 
 */
public class PropertiesUtil {
	private static Properties props = new Properties();
	static {
		InputStream ips = PropertiesUtil.class.getClassLoader()
				.getResourceAsStream("opt.properties");
		try {
			props.load(ips);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
 
	public static String getValue(String key) {
		return props.getProperty(key);
	}
}

opt.properties文件：

1
2
3

UserService.regist=\u7528\u6237\u6ce8\u518c\u64cd\u4f5c
UserService.login=\u7528\u6237\u767b\u5f55\u64cd\u4f5c
DeptService.delete=\u90e8\u95e8\u5220\u9664

properties文件中的值是汉字转为的ascii字符,如下：
UserService.regist=用户注册操作
UserService.login=用户登录操作
DeptService.delete=部门删除

widows下可以使用jdk－>bin目录下的native2ascii工具转换，
linux下可以在终端中使用命令：native2ascii.

关注点切面类：
ExceptionLogger.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package com.weishuzhai.aspect;
 
import java.io.IOException;
import java.util.Date;
 
import com.weishuzhai.util.FileUtil;
 
public class ExceptionLogger {
	// 把异常信息以文件形式记录下来
	public void loggerException(Exception ex) {
		try {
			System.out.println("------Has Exception------");
			String msg = "异常类型：" + ex.getMessage() + "时间：" + new Date();
			FileUtil.write("exception.log", true, msg);
			FileUtil.write("exception.log", true, ex.toString());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

OptLogger.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package com.weishuzhai.aspect;
 
import org.aspectj.lang.ProceedingJoinPoint;
 
import com.weishuzhai.util.FileUtil;
import com.weishuzhai.util.PropertiesUtil;
 
public class OptLogger {
	//将用户操作记录下来
	public Object loggerOpt(ProceedingJoinPoint pjp) throws Throwable{
		//获取要执行的方法名和目标对象类型
		String methodName = pjp.getSignature().getName();
		String clazzName = pjp.getTarget().getClass().getSimpleName();
		//去opt.properties中寻找对应中文操作信息
		String key = clazzName+"."+methodName;
		String optMsg = PropertiesUtil.getValue(key);
		System.out.println("key:"+key);
		System.out.println("optMsg:"+optMsg);
 
		Object retVal = pjp.proceed();//调用目标对象的方法
		//记录操作
		FileUtil.write("opt.log",true,optMsg);
		return retVal;
	}
}

DAO使用学习笔记2中的DAO：
UserDAO.java:

1
2
3
4
5
6
7

package com.weishuzhai.target;
 
public interface UserDAO {
	public void save();
 
	public void findByEmail(String email);
}

实现类UserDAOImpl.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package com.weishuzhai.target;
 
public class JDBCUserDAOImpl implements UserDAO {
 
	public void findByEmail(String email) {
		System.out.println("采用JDBC技术保存用户信息");
 
	}
 
	public void save() {
		System.out.println("采用JDBC技术查询用户信息");
 
	}
 
}

目标对象，为了进行测试，故意制造了一些异常。
UserService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package tarena.user;
 
import tarena.target.UserDAO;
 
public class UserService {
	private UserDAO userDao;
 
	public void setUserDao(UserDAO userDao) {
		this.userDao = userDao;
	}
 
	/**
	 * 注册业务方法
	 * 
	 */
	public void regist() {
		// System.out.println("--欢迎使用该功能---");
		System.out.println("调用DAO执行注册处理");
		userDao.save();
	}
 
	/**
	 * 登录业务方法
	 * 
	 */
	public void login() {
		// System.out.println("--欢迎使用该功能---");
		System.out.println("调用DAO执行登录处理");
		userDao.findByEmail("zhangsan@tom.com");
		String s = null;
		s.length();
	}
 
}

package com.weishuzhai.user;

public class DeptService {
public void delete() {
System.out.println(“删除部门信息操作”);
String s = “abc”;
Integer i = Integer.parseInt(s);
}
}

spring配置文件spring-aop.xml进行配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

< ?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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
		<bean id="userService" class="com.weishuzhai.user.UserService">
			<property name="userDao" ref="userDAO"></property>
		</bean>	
		<bean id="userDAO" class="com.weishuzhai.target.JDBCUserDAOImpl"></bean>
		<bean id="deptService" class="com.weishuzhai.user.DeptService"></bean>		
		<!-- 以AOP方式记录异常信息和成功操作信息 -->
		<bean id="exLogger" class="com.weishuzhai.aspect.ExceptionLogger"></bean>
		<bean id="optLogger" class="com.weishuzhai.aspect.OptLogger"></bean>
		<aop:config>
			<!-- 定义切入点 -->
			<aop:pointcut id="loggerPointcut" expression="bean(*Service)"></aop:pointcut>
			<!-- 定义切面,记录异常日志 -->
			<aop:aspect id="exLoggerAspect" ref="exLogger">
				<!-- 异常通知 throwing属性值为loggerException方法的参数名 -->
				<aop:after -throwing pointcut-ref="loggerPointcut" method="loggerException" throwing="ex"/>
			</aop:aspect>
			<!-- 定义切面,记录成功操作日志 -->
			<aop:aspect id="optloggerAspect" ref="optLogger">
				 <!-- 环绕通知 -->
				 <aop:around pointcut-ref="loggerPointcut" method="loggerOpt"/>			
			</aop:aspect>
		</aop:config>
</beans>

测试：
TestLogger.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

 package com.weishuzhai.test;
 
 
 
import org.junit.Test;
 
import org.springframework.context.ApplicationContext;
 
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 
 
import com.weishuzhai.user.DeptService;
 
import com.weishuzhai.user.UserService;
 
 
 
/**
 
 * 测试异常日志和成功操作日志
 
 * 
 
 * @author Administrator
 
 * 
 
 */
 
public class TestLogger {
 
	@Test
 
	public void testRegist() {
 
		ApplicationContext ac = new ClassPathXmlApplicationContext(
 
				"spring-aop.xml");
 
		UserService userService = (UserService) ac.getBean("userService");
 
		userService.regist();
 
	}
 
 
 
	@Test
 
	public void testLogin() {
 
		ApplicationContext ac = new ClassPathXmlApplicationContext(
 
				"spring-aop.xml");
 
		UserService userService = (UserService) ac.getBean("userService");
 
		userService.login();
 
	}
 
 
 
	@Test
 
	public void testDeptDelete() {
 
		ApplicationContext ac = new ClassPathXmlApplicationContext(
 
				"spring-aop.xml");
 
		DeptService deptService = (DeptService) ac.getBean("deptService");
 
		deptService.delete();
 
	} 
}

运行结果：

控制台：

exception.log:

opt.log:

—————————————————

分享到：
| Spring框架学习笔记2：AOP及其相关概念和 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring学习笔记（15）----使用Spring的注解方式实现AOP

    在本篇Spring学习笔记中，我们将深入探讨如何利用Spring框架的注解方式来实现面向切面编程（AOP）。AOP是一种编程范式，它允许我们定义横切关注点，如日志、事务管理等，然后将这些关注点模块化并插入到应用程序的多...

    Spring学习笔记(16)----使用Spring配置文件实现AOP

    在本篇Spring学习笔记中，我们将深入探讨如何利用Spring配置文件来实现面向切面编程（AOP）。面向切面编程是Spring框架的核心特性之一，它允许我们把关注点分离，将横切关注点（如日志、事务管理、权限控制等）与...

    Java Spring框架学习笔记（内附源码）.pdf

    本学习笔记提供了丰富的源码示例，帮助读者更好地理解和应用Spring框架。 首先，需要明确Spring是一个开源框架，它旨在简化Java EE（现在称为Jakarta EE）的开发。Spring框架的核心是提供了一个轻量级、解耦的容器...

    SpringAop学习笔记以及实现Demo

    **Spring AOP 学习笔记及实现Demo** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架中的一个重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。AOP的主要目的...

    spring框架学习笔记

    Spring框架是Java应用开发中广泛使用的轻量级框架，它以IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）为核心，提供了丰富的功能，包括但不限于组件管理、AOP（Aspect Oriented ...

    spring学习笔记

    ### Spring学习笔记知识点详解 #### 一、Spring框架概述 1. **Spring框架的作用：** - 对大量企业级服务的API进行封装，简化复杂的API使用难度。 - 提供了事务管理、资源获取等方面的便利支持，使得企业数据操作...

    Spring学习笔记&源码

    本资料“Spring学习笔记&源码”是基于网易云课堂黑马程序员的Spring四天精通课程，旨在帮助学习者深入理解和实践Spring框架。 笔记部分可能会涵盖以下内容： 1. **Spring概述**：介绍Spring框架的历史、特点和主要...

    SSM 框架整合教程：三、SpringMVC-尚硅谷学习笔记 2022 年

    1. **Spring框架**：作为基础，Spring提供了依赖注入（DI）和面向切面编程（AOP），管理着整个应用的bean。 2. **SpringMVC**：作为Web层，处理HTTP请求，转发到对应的处理器（Controller），然后返回响应。 3. **...

    ssh-aop笔记

    SSH-AOP笔记主要涵盖的是Spring、Struts和Hibernate三大框架集成使用时，如何结合Aspect Oriented Programming（面向切面编程）的理念进行应用增强。在Java企业级开发中，SSH是常用的MVC架构，而AOP则是一种编程范式...

    Spring AOP源码笔记

    Spring AOP是Spring框架的核心组件之一，它实现了面向切面编程（Aspect-Oriented Programming，简称AOP），允许开发者定义“切面”，这些切面可以封装横切关注点，如日志记录、事务管理等。AOP的主要目标是将这些...

    Spring2.0精简笔记

    - **AOP**是Spring支持的一种编程范式，主要用于分离横切关注点（Cross-cutting Concerns），如日志记录、性能统计、安全控制、事务处理等。通过定义切面（Aspect），可以在不修改业务逻辑代码的前提下添加这些横切...

    spring2.5 学习笔记

    ### Spring 2.5 学习笔记知识点梳理 #### 第一课：面向抽象编程 - **定义**：面向抽象编程是一种编程范式，强调通过抽象类或接口来设计程序结构，减少对具体实现的依赖。 - **优势**： - 提高了系统的可维护性与...

    Spring笔记示例源代码

    "Spring笔记示例源代码"这个资源很可能是为了帮助学习者深入理解Spring框架的各种功能和用法而提供的实际代码示例。 1. **Spring IoC**：IoC是Spring的核心特性，它将对象的创建和管理权交给Spring容器，使得开发者...

    JavaEE精讲之Spring框架实战 ——学习笔记.zip

    在本学习笔记中，我们将深入探讨JavaEE中的Spring框架，这是一个强大的、全面的企业级应用程序开发框架，它简化了Java开发并提供了丰富的功能。Spring的核心特性包括依赖注入（DI）、面向切面编程（AOP）以及对Java ...

    Spring5框架课堂笔记.7z

    这份"Spring5框架课堂笔记.pdf"应该详细讲解了以上各知识点，并可能包含示例代码和实践指导，对于学习和进阶Spring框架是非常宝贵的资源。通过深入学习和实践，开发者可以有效地利用Spring5框架构建高效、可维护的...

    Spring AOP 用法笔记

    Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架中的一个重要组成部分，它提供了一种将业务逻辑与系统服务（如日志、事务管理等）分离的方法，使得我们可以更好地关注核心业务，而无需在每个...

    Spring AOP 复习笔记.rar

    Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架的重要组成部分，它允许程序员定义“切面”，这些切面可以封装跨越多个对象的行为，比如日志、事务管理等。AOP提供了一种模块化的方式，将核心...

    学习Spring笔记_AOP_Annotation实现和XML实现

    Spring框架是Java开发中不可或缺的一部分，它以其强大的...通过阅读《学习Spring笔记_AOP_Annotation实现和XML实现》以及探索`Spring_AOP_XML`中的示例，开发者可以深入理解这两个实现方式，并在实际项目中灵活运用。

    Spring 入门教程资料（源码源代码及课程笔记）

    8. **课程笔记**：文件名中的 "spring" 可能包含关于 Spring 框架的详细笔记，这将帮助学习者巩固理论知识，理解讲师讲解的重点。 通过这些教程，初学者能够逐步建立起对 Spring 框架的整体认识，并通过实际操作...

Magicbox
Global site tag (gtag.js) - Google Analytics